LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/ljc2154[P]Rummy/rummy.cpp
// Function: playAgentTurn(State&)
void playAgentTurn(State &state)
{
	/* Must be rewritten with dropCard function */
	if (takeTurnCard(state))
	{
		cout << "The computer took the turn card!" << endl;
		int turnCard = state.turnCard;
		state.agentHand.push_back(turnCard);
		state.turnCard = removeWorstCard(state);
	}
	else
	{
		cout << "The computer drew from the deck." << endl;
		state.agentHand.push_back(state.deck.back());
		state.remaining.remove(state.deck.back());
		state.deck.pop_back();
		state.turnCard = removeWorstCard(state);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
leaq 0x10(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq 0x3a1e
movq %r14, %rdi
callq 0x33dc
movl %eax, %ebp
leaq 0x58(%rsp), %r14
movq (%r14), %rdi
cmpq %r14, %rdi
je 0x201e
movq (%rdi), %r15
movl $0x18, %esi
callq 0x1100
movq %r15, %rdi
cmpq %r14, %r15
jne 0x2009
movq 0x40(%rsp), %rdi
testq %rdi, %rdi
je 0x2035
movq 0x50(%rsp), %rsi
subq %rdi, %rsi
callq 0x1100
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x204c
movq 0x38(%rsp), %rsi
subq %rdi, %rsi
callq 0x1100
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x2063
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x1100
movq 0x3f66(%rip), %r14      # 0x5fd0
testb %bpl, %bpl
je 0x20ca
leaq 0x20f8(%rip), %rsi      # 0x416e
movl $0x20, %edx
movq %r14, %rdi
callq 0x1110
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x10e0
movsbl %al, %esi
movq %r14, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1090
movl 0x60(%rbx), %eax
movl %eax, 0xc(%rsp)
movq 0x20(%rbx), %rsi
cmpq 0x28(%rbx), %rsi
je 0x2125
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x20(%rbx)
jmp 0x2154
leaq 0x20be(%rip), %rsi      # 0x418f
movl $0x20, %edx
movq %r14, %rdi
callq 0x1110
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x10e0
movsbl %al, %esi
movq %r14, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1090
movq 0x8(%rbx), %rdx
movq 0x20(%rbx), %rsi
addq $-0x4, %rdx
cmpq 0x28(%rbx), %rsi
je 0x2135
movl (%rdx), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x20(%rbx)
jmp 0x213e
leaq 0x18(%rbx), %rdi
leaq 0xc(%rsp), %rdx
callq 0x3cf6
jmp 0x2154
leaq 0x18(%rbx), %rdi
callq 0x3cf6
leaq 0x48(%rbx), %rdi
movq 0x8(%rbx), %rsi
addq $-0x4, %rsi
callq 0x3b38
addq $-0x4, 0x8(%rbx)
movq %rbx, %rdi
callq 0x379a
movl %eax, 0x60(%rbx)
addq $0x78, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x3ac4
movq %rbx, %rdi
callq 0x1150
// File: /workspace/github_cpp_makefile_star2_O1/ljc2154[P]Rummy/rummy.cpp
// Function: shuffle(std::vector<int, std::allocator<int>>&)
void shuffle(vector<int> &deck)
{
	srand(time(NULL));
	int size = deck.size();
	for (int i = size-1; i >0; i--)
	{
		int swapPos = rand() % i;
		swap(deck, i, swapPos);
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %edi, %edi
callq 0x10c0
movl %eax, %edi
callq 0x10d0
movq 0x8(%rbx), %r14
subq (%rbx), %r14
shrq $0x2, %r14
cmpl $0x2, %r14d
jl 0x21f2
andl $0x7fffffff, %r14d      # imm = 0x7FFFFFFF
decq %r14
callq 0x1050
cltd
idivl %r14d
movq (%rbx), %rax
movl (%rax,%r14,4), %ecx
movslq %edx, %rdx
movl (%rax,%rdx,4), %esi
movl %esi, (%rax,%r14,4)
movl %ecx, (%rax,%rdx,4)
leaq -0x1(%r14), %rax
incq %r14
cmpq $0x2, %r14
movq %rax, %r14
jg 0x21c5
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/ljc2154[P]Rummy/rummy.cpp
// Function: getNewDeck()
vector<int> getNewDeck()
{
	vector<int> deck;
	for (int i = 0; i < 52; i++)
	{
		deck.push_back(i);
	}
	shuffle(deck);
	return deck;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq $0x0, 0x10(%rdi)
leaq 0x4(%rsp), %r14
movl $0x0, (%r14)
xorl %eax, %eax
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x2233
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x223e
movq %rbx, %rdi
movq %r14, %rdx
callq 0x3cf6
movl 0x4(%rsp), %ecx
leal 0x1(%rcx), %eax
movl %eax, 0x4(%rsp)
cmpl $0x33, %ecx
jl 0x221d
movq %rbx, %rdi
callq 0x2195
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq (%rbx), %rdi
testq %rdi, %rdi
je 0x2278
movq 0x10(%rbx), %rsi
subq %rdi, %rsi
callq 0x1100
movq %r14, %rdi
callq 0x1150
// File: /workspace/github_cpp_makefile_star2_O1/ljc2154[P]Rummy/rummy.cpp
// Function: initializeRemaining[abi:cxx11]()
list<int> initializeRemaining()
{
	list<int> remaining;
	for (int i = 0; i < 52; i++)
		remaining.push_back(i);
	return remaining;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq %rdi, 0x8(%rdi)
movq %rdi, (%rdi)
movq $0x0, 0x10(%rdi)
xorl %ebp, %ebp
movl $0x18, %edi
callq 0x10f0
movl %ebp, 0x10(%rax)
movq %rax, %rdi
movq %rbx, %rsi
callq 0x1040
incq 0x10(%rbx)
incl %ebp
cmpl $0x34, %ebp
jne 0x229b
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %rbx, %rdi
je 0x22ec
movq (%rdi), %r15
movl $0x18, %esi
callq 0x1100
movq %r15, %rdi
cmpq %rbx, %r15
jne 0x22d7
movq %r14, %rdi
callq 0x1150
// File: /workspace/github_cpp_makefile_star2_O1/ljc2154[P]Rummy/rummy.cpp
// Function: dealCards(std::vector<int, std::allocator<int>>&, std::vector<int, std::allocator<int>>&, std::vector<int, std::allocator<int>>&)
void dealCards(vector<int> &deck, vector<int> &userHand, vector<int> &agentHand)
{
	for (int i = 0; i < 14; i ++)
	{
		int topCard = deck.back();
		deck.pop_back();
		if (i%2 == 0)
			userHand.push_back(topCard);
		else
			agentHand.push_back(topCard);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %ebp, %ebp
leaq 0xc(%rsp), %r12
movq 0x8(%r15), %rcx
movl -0x4(%rcx), %eax
addq $-0x4, %rcx
movl %eax, 0xc(%rsp)
movq %rcx, 0x8(%r15)
testb $0x1, %bpl
jne 0x233f
movq 0x8(%r14), %rsi
cmpq 0x10(%r14), %rsi
je 0x2355
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%r14)
jmp 0x2365
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x235a
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x2365
movq %r14, %rdi
jmp 0x235d
movq %rbx, %rdi
movq %r12, %rdx
callq 0x3cf6
incl %ebp
cmpl $0xe, %ebp
jne 0x2310
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/ljc2154[P]Rummy/rummy.cpp
// Function: mergeSort(std::vector<int, std::allocator<int>>&, int, int)
void mergeSort(vector<int> &integers, int start, int finish)
{
	if ((finish - start) <= 1)
		return;
	int m = (finish - start) / 2;
	mergeSort(integers, start, start+m);
	mergeSort(integers, start+m, finish);

	vector<int> temp;
	merge(integers, start, start+m, finish, temp);
	int tempIndex = 0;
	for (int i = start; i < finish; i++)
		integers[i] = temp[tempIndex++];
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movl %edx, %r15d
subl %esi, %r15d
cmpl $0x2, %r15d
jl 0x2487
movl %edx, %ebx
movl %esi, %ebp
movq %rdi, %r14
shrl %r15d
addl %esi, %r15d
movl %r15d, %edx
callq 0x23c7
movq %r14, %rdi
movl %r15d, %esi
movl %ebx, %edx
callq 0x23c7
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
callq 0x3bc8
leaq 0x20(%rsp), %rdi
movq %rsp, %r8
movl %ebp, %esi
movl %r15d, %edx
movl %ebx, %ecx
callq 0x2a2f
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x244b
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x1100
subl %ebp, %ebx
jle 0x2471
movq (%rsp), %rax
movslq %ebp, %rcx
shlq $0x2, %rcx
addq (%r14), %rcx
xorl %edx, %edx
movl (%rax,%rdx,4), %esi
movl %esi, (%rcx,%rdx,4)
leaq 0x1(%rdx), %rsi
movq %rsi, %rdx
cmpq %rsi, %rbx
jne 0x245f
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x2487
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x1100
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
testq %rdi, %rdi
je 0x24b1
movq 0x30(%rsp), %rsi
subq %rdi, %rsi
callq 0x1100
jmp 0x24b1
movq %rax, %rbx
movq (%rsp), %rdi
testq %rdi, %rdi
je 0x24c7
movq 0x10(%rsp), %rsi
subq %rdi, %rsi
callq 0x1100
movq %rbx, %rdi
callq 0x1150
// File: /workspace/github_cpp_makefile_star2_O1/ljc2154[P]Rummy/rummy.cpp
// Function: printOpponentHandandDeck()
void printOpponentHandandDeck()
{
	/* Printing out what looks like opponent's hand */
	for (int i = 0; i < 10; i++)
	{
		for (int j = 0; j < 56; j++)
		{
			int k = j % 8;
			if (k == 7)
				cout << "* ";
			else if (i == 0 || i == 9 || k == 0)
				cout << "*";
			else
				cout << "?";
		}
		cout << endl;
	}
	cout << endl;

	/* Printing out what looks like a deck */
	for (int i = 0; i < 10; i++)
	{
		for (int j = 0; j < 8; j++)
		{
			if (i == 0 || i == 9 || j == 0 || j == 7)
				cout << "*";
			else
				cout << "?";
		}
		cout << endl;
	}
	cout << endl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
xorl %ebp, %ebp
movq 0x3a9b(%rip), %rbx      # 0x5fd0
leaq 0x1acb(%rip), %r14      # 0x4007
leaq 0x1ac1(%rip), %r12      # 0x4004
leaq 0x1abf(%rip), %r15      # 0x4009
xorl %r13d, %r13d
movl %r13d, %eax
andl $0x7, %eax
je 0x2570
cmpl $0x7, %eax
jne 0x2567
movl $0x2, %edx
movq %rbx, %rdi
movq %r12, %rsi
jmp 0x257b
cmpl $0x9, %ebp
je 0x2570
testl %ebp, %ebp
jne 0x258b
movl $0x1, %edx
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1110
incl %r13d
cmpl $0x38, %r13d
jne 0x254d
jmp 0x2598
movl $0x1, %edx
movq %rbx, %rdi
movq %r15, %rsi
jmp 0x257b
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x10e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1090
incl %ebp
cmpl $0xa, %ebp
jne 0x254a
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x10e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1090
xorl %ebp, %ebp
testl %ebp, %ebp
sete %al
cmpl $0x9, %ebp
sete %r12b
orb %al, %r12b
movl $0x8, %r13d
cmpl $0x8, %r13d
movq %r15, %rsi
cmoveq %r14, %rsi
testb %r12b, %r12b
cmovneq %r14, %rsi
cmpl $0x1, %r13d
cmoveq %r14, %rsi
movl $0x1, %edx
movq %rbx, %rdi
callq 0x1110
decl %r13d
jne 0x2604
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x10e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1090
incl %ebp
cmpl $0xa, %ebp
jne 0x25ef
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x10e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1090
// File: /workspace/github_cpp_makefile_star2_O1/ljc2154[P]Rummy/rummy.cpp
// Function: printTurnCard(int)
void printTurnCard(int v)
{
	char suit = getSuit(v);
	char rank = getRank(v);
	for (int i = 0; i < 10; i++)
	{
		for (int j = 0; j < 8; j++)
		{
			if (i == 0 || i == 9 || j == 0 || j == 7)
				cout << "*";
			else if ((j == 1 && i == 1) || (j == 6 && i == 8) || (j == 3 && i == 4))
				cout << rank;
			else if ((j == 6 && i == 1) || (j == 1 && i == 8) || (j == 4 && i == 5))
				cout << suit;
			else
				cout << " ";
		}
		cout << endl;
	}
	cout << endl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movb $0x26, %al
movl %eax, 0xc(%rsp)
cmpl $0xd, %edi
jl 0x26cb
movb $0x25, %al
movl %eax, 0xc(%rsp)
cmpl $0x1a, %edi
jl 0x26cb
cmpl $0x27, %edi
movl $0x24, %eax
movl $0x40, %ecx
cmovll %eax, %ecx
movl %ecx, 0xc(%rsp)
callq 0x24ee
movb %al, 0x9(%rsp)
xorl %ecx, %ecx
movq 0x38f3(%rip), %rbx      # 0x5fd0
testl %ecx, %ecx
sete %al
cmpl $0x9, %ecx
sete %r12b
orb %al, %r12b
movl $0x4, %r15d
movl %ecx, %r13d
xorl $0x1, %r13d
movl %ecx, %r14d
xorl $0x4, %r14d
movl %ecx, %ebp
xorl $0x8, %ebp
movl %ecx, 0x10(%rsp)
xorl $0x5, %ecx
movl %ecx, 0x14(%rsp)
cmpl $0x4, %r15d
sete %al
cmpl $-0x3, %r15d
je 0x2746
orb %r12b, %al
jne 0x2746
movl %r15d, %eax
xorl $0x3, %eax
movl %r13d, %ecx
orl %eax, %ecx
jne 0x2765
movb 0x9(%rsp), %al
movb %al, 0xa(%rsp)
movl $0x1, %edx
movq %rbx, %rdi
leaq 0xa(%rsp), %rsi
jmp 0x2755
movl $0x1, %edx
movq %rbx, %rdi
leaq 0x18b2(%rip), %rsi      # 0x4007
callq 0x1110
decl %r15d
cmpl $-0x4, %r15d
jne 0x2710
jmp 0x27c5
movl %r15d, %ecx
xorl $-0x2, %ecx
movl %r15d, %edx
xorl $0x1, %edx
orl %r14d, %edx
sete %dl
movl %ebp, %esi
orl %ecx, %esi
je 0x272f
testb %dl, %dl
jne 0x272f
orl %ebp, %eax
sete %dl
movl 0x14(%rsp), %eax
orl %r15d, %eax
sete %al
orl %r13d, %ecx
je 0x27ae
testb %dl, %dl
jne 0x27ae
testb %al, %al
jne 0x27ae
movl $0x1, %edx
movq %rbx, %rdi
leaq 0x1859(%rip), %rsi      # 0x4005
jmp 0x2755
movl 0xc(%rsp), %eax
movb %al, 0xb(%rsp)
movl $0x1, %edx
movq %rbx, %rdi
leaq 0xb(%rsp), %rsi
jmp 0x2755
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x10e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1090
movl 0x10(%rsp), %ecx
incl %ecx
cmpl $0xa, %ecx
jne 0x26dd
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x10e0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1030
movq %rax, %rdi
callq 0x1090
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/ljc2154[P]Rummy/rummy.cpp
// Function: merge(std::vector<int, std::allocator<int>>, int, int, int, std::vector<int, std::allocator<int>>&)
void merge(vector<int> integers, int a1, int m, int b2, vector<int> &output)
{
	int a2, b1;
	a2 = b1 = m;
	while (a1 < a2 && b1 < b2)
	{
		if (integers[a1] <= integers[b1])
			output.push_back(integers[a1++]);
		else
			output.push_back(integers[b1++]);
	}

	while (a1 < a2)
		output.push_back(integers[a1++]);
	while (b1 < b2)
		output.push_back(integers[b1++]);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movl %ecx, %ebp
movl %edx, %r15d
movl %esi, %r12d
movq %rdi, %r14
cmpl %edx, %esi
setge %al
cmpl %ecx, %edx
setge %cl
movl %edx, %r13d
orb %al, %cl
jne 0x2ab5
movslq %r12d, %rcx
movq (%r14), %rax
movl (%rax,%rcx,4), %edx
movslq %r13d, %rdi
movl (%rax,%rdi,4), %r8d
cmpl %r8d, %edx
jle 0x2a80
incl %r13d
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x2a99
movl %r8d, (%rsi)
jmp 0x2a8f
incl %r12d
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x2a9f
movl %edx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x2aab
leaq (%rax,%rdi,4), %rdx
jmp 0x2aa3
leaq (%rax,%rcx,4), %rdx
movq %rbx, %rdi
callq 0x3cf6
cmpl %r15d, %r12d
jge 0x2ab5
cmpl %ebp, %r13d
jl 0x2a59
subl %r12d, %r15d
jle 0x2af0
movslq %r12d, %r12
shlq $0x2, %r12
movq (%r14), %rdx
addq %r12, %rdx
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x2adf
movl (%rdx), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x2ae7
movq %rbx, %rdi
callq 0x3cf6
addq $0x4, %r12
decl %r15d
jne 0x2ac1
subl %r13d, %ebp
jle 0x2b2a
movslq %r13d, %r15
shlq $0x2, %r15
movq (%r14), %rdx
addq %r15, %rdx
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x2b1a
movl (%rdx), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rbx)
jmp 0x2b22
movq %rbx, %rdi
callq 0x3cf6
addq $0x4, %r15
decl %ebp
jne 0x2afc
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/akw0088[P]openssl/crc32.c
// Function: crc32
void crc32(const void *data, size_t n_bytes, uint32_t* crc)
{
	static uint32_t table[0x100];

	if(!*table)
	{
		for(size_t i = 0; i < 0x100; ++i)
		{
			table[i] = crc32_for_byte(i);
		}
	}

	for(size_t i = 0; i < n_bytes; ++i)
	{
		*crc = table[(uint8_t)*crc ^ ((uint8_t*)data)[i]] ^ *crc >> 8;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
cmpl $0x0, 0x2eb4(%rip)      # 0x4070
leaq 0x2ead(%rip), %rax      # 0x4070
jne 0x1201
xorl %ecx, %ecx
movl $0x8, %r9d
movl %ecx, %r8d
movl $0xedb88320, %r10d      # imm = 0xEDB88320
testb $0x1, %r8b
je 0x11df
xorl %r10d, %r10d
shrl %r8d
xorl %r10d, %r8d
decl %r9d
jne 0x11d0
xorl $0xff000000, %r8d       # imm = 0xFF000000
movl %r8d, (%rax,%rcx,4)
incq %rcx
cmpq $0x100, %rcx            # imm = 0x100
jne 0x11c7
testq %rsi, %rsi
je 0x1228
movl (%rdx), %ecx
xorl %r8d, %r8d
movzbl %cl, %r9d
movzbl (%rdi,%r8), %r10d
xorl %r9d, %r10d
shrl $0x8, %ecx
xorl (%rax,%r10,4), %ecx
movl %ecx, (%rdx)
incq %r8
cmpq %r8, %rsi
jne 0x120b
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/akw0088[P]openssl/crc32.c
// Function: main
int main(int argc, char** argv)
{
	FILE *fp;
	char buf[1L << 15];

	for(int i = argc > 1; i < argc; ++i)
	{
		if((fp = i ? fopen(argv[i], "rb"): stdin))
		{ 
			uint32_t crc = 0;
			while(!feof(fp) && !ferror(fp))
			{
				crc32(buf, fread(buf, 1, sizeof(buf), fp), &crc);
			}
			if(!ferror(fp))
			{
				printf("%08X%s%s\n", crc, argc > 2? "\t": "", argc > 2? argv[i]: "");
			}
			if(i)
			{
				fclose(fp);
			}
		}
	}
	return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x8018, %rsp           # imm = 0x8018
movq %rsi, -0x38(%rbp)
xorl %eax, %eax
cmpl $0x2, %edi
setge %al
movl %edi, -0x2c(%rbp)
cmpl %edi, %eax
jge 0x1349
xorl %r14d, %r14d
movl -0x2c(%rbp), %eax
cmpl $0x2, %eax
setge %r14b
leaq 0xda8(%rip), %rcx       # 0x2011
leaq 0xda2(%rip), %rdx       # 0x2012
cmovleq %rdx, %rcx
movq %rcx, -0x40(%rbp)
movl %eax, %ebx
leaq -0x8040(%rbp), %r12
leaq -0x30(%rbp), %r13
testq %r14, %r14
je 0x12a3
movq -0x38(%rbp), %rax
movq (%rax,%r14,8), %rdi
leaq 0xd6b(%rip), %rsi       # 0x2004
callq 0x1080
movq %rax, %r15
jmp 0x12ad
movq 0x2d36(%rip), %rax      # 0x3fe0
movq (%rax), %r15
testq %r15, %r15
je 0x133d
movl $0x0, -0x30(%rbp)
movq %r15, %rdi
callq 0x1070
testl %eax, %eax
jne 0x12fa
movq %r15, %rdi
callq 0x1030
testl %eax, %eax
jne 0x12fa
movl $0x1, %esi
movl $0x8000, %edx           # imm = 0x8000
movq %r12, %rdi
movq %r15, %rcx
callq 0x1040
movq %r12, %rdi
movq %rax, %rsi
movq %r13, %rdx
callq 0x11b1
jmp 0x12bd
movq %r15, %rdi
callq 0x1030
testl %eax, %eax
jne 0x1330
leaq 0xd05(%rip), %rcx       # 0x2012
cmpl $0x3, -0x2c(%rbp)
jl 0x131b
movq -0x38(%rbp), %rax
movq (%rax,%r14,8), %rcx
movl -0x30(%rbp), %esi
leaq 0xce2(%rip), %rdi       # 0x2007
movq -0x40(%rbp), %rdx
xorl %eax, %eax
callq 0x1060
testq %r14, %r14
je 0x133d
movq %r15, %rdi
callq 0x1050
incq %r14
cmpq %rbx, %r14
jne 0x1285
xorl %eax, %eax
addq $0x8018, %rsp           # imm = 0x8018
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/bitwiseshiftleft[P]crandom/raw_random.cpp
// Function: main
int main(int argc, char **argv) {
  (void) argc; (void) argv;
  
  const int buffer_size = 65536;

  // auto-seeded?
  prg_generator<chacha> gen(true);

  unsigned char buffer[buffer_size];

  if (isatty(1)) {
    fprintf(stderr, "%s: refusing to write random data to a terminal.\n", argv[0]);
    return 1;
  }

  while(true) {
    gen.randomize(buffer, buffer_size);
    long long int ret = write(1, buffer, buffer_size);
    assert(ret == buffer_size);
  }

  return 2;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x10038, %rsp          # imm = 0x10038
movq %rsi, %rbx
leaq 0x8(%rsp), %r14
movq %r14, %rdi
movl $0x80, %esi
movl $0x1, %edx
movl $0x20, %ecx
callq 0x145c
leaq 0x4af4(%rip), %rax      # 0x5d60
movq %rax, (%r14)
movq $0x0, 0x20(%r14)
movl $0x1, %edi
callq 0x1110
testl %eax, %eax
je 0x12ba
movq 0x4d54(%rip), %rax      # 0x5fe0
movq (%rax), %rdi
movq (%rbx), %rdx
leaq 0x2d6b(%rip), %rsi      # 0x4004
xorl %eax, %eax
callq 0x10f0
leaq 0x8(%rsp), %rdi
callq 0x148c
movl $0x1, %eax
addq $0x10038, %rsp          # imm = 0x10038
popq %rbx
popq %r14
retq
leaq 0x8(%rsp), %rbx
leaq 0x30(%rsp), %r14
movl $0x10000, %edx          # imm = 0x10000
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1324
movl $0x10000, %edx          # imm = 0x10000
movl $0x1, %edi
movq %r14, %rsi
callq 0x1040
cmpq $0x10000, %rax          # imm = 0x10000
je 0x12c4
leaq 0x2d41(%rip), %rdi      # 0x4036
leaq 0x2d4d(%rip), %rsi      # 0x4049
leaq 0x2d55(%rip), %rcx      # 0x4058
movl $0x1c, %edx
callq 0x1080
jmp 0x130f
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x148c
movq %rbx, %rdi
callq 0x1120
// File: /workspace/github_cpp_makefile_star2_O1/bitwiseshiftleft[P]crandom/./crandom.hpp
// Function: crandom::generator_base::randomize(unsigned char*, unsigned long)
void randomize(unsigned char *__restrict__ output, size_t n) {
    if (unlikely(!fill)) refill();
    if (likely(fill >= n)) {
      fill -= (u_int32_t)n;
      
      // the compiler will optimize this if n is known and small (eg 4)
      memcpy(output, buffer+fill, n);
      bzero(buffer+fill, n);
    } else {
      randomize_slow_case(output, n);
    }
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
cmpl $0x0, 0x14(%rdi)
je 0x1375
movl 0x14(%r15), %r12d
cmpq %rbx, %r12
jb 0x1380
subl %ebx, %r12d
movl %r12d, 0x14(%r15)
addq 0x18(%r15), %r12
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x10b0
movq %r12, %rdi
xorl %esi, %esi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1070
movq (%r15), %rax
movq %r15, %rdi
callq *0x8(%rax)
jmp 0x133b
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x14a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/jmfenner92[P]Log-Parser/src/log_parser.cpp
// Function: timeConverter(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
float timeConverter(string timeString) {
	string str = timeString.substr(0, timeString.length() - 2);
	float result = atof(str.c_str());
	string time = timeString.substr(timeString.length() - 2, 2);
	if(time == "us")
		return pow(result, -6);
	else if (time == "ns")
		return pow(result, -9);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
movq 0x8(%rdi), %rcx
addq $-0x2, %rcx
leaq -0x58(%rbp), %r14
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0x2190
movq (%r14), %rdi
callq 0x21f0
movsd %xmm0, -0x18(%rbp)
movq 0x8(%rbx), %rdx
addq $-0x2, %rdx
leaq -0x38(%rbp), %rdi
movl $0x2, %ecx
movq %rbx, %rsi
callq 0x2190
xorps %xmm0, %xmm0
cvtsd2ss -0x18(%rbp), %xmm0
movss %xmm0, -0x18(%rbp)
leaq 0x3156(%rip), %rsi      # 0x60c7
leaq -0x38(%rbp), %rdi
callq 0x2060
testl %eax, %eax
je 0x2f98
leaq 0x3145(%rip), %rsi      # 0x60ca
leaq -0x38(%rbp), %rdi
callq 0x2060
movsd 0x30aa(%rip), %xmm1     # 0x6040
jmp 0x2fa0
movsd 0x3098(%rip), %xmm1     # 0x6038
xorps %xmm0, %xmm0
cvtss2sd -0x18(%rbp), %xmm0
callq 0x22a0
movsd %xmm0, -0x18(%rbp)
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2fcb
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x2170
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x2fe4
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x2170
xorps %xmm0, %xmm0
cvtsd2ss -0x18(%rbp), %xmm0
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3011
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x2170
movq %rbx, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O1/jmfenner92[P]Log-Parser/src/CmdRecord.cpp
// Function: CmdRecord::CmdRecord()
CmdRecord::CmdRecord()
{
	line_number = "";
	address = "";
	//data [100];
	std::vector<std::string>(100);
	size = "";
	cycle = "";
	reltime = "";
	wordsLength = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, -0x50(%rbp)
movq %rax, (%rdi)
xorl %eax, %eax
movq %rax, 0x8(%rdi)
movb %al, 0x10(%rdi)
leaq 0x20(%rdi), %rcx
movq %rcx, -0x60(%rbp)
leaq 0x30(%rdi), %rcx
movq %rcx, -0x48(%rbp)
movq %rcx, 0x20(%rdi)
movq %rax, 0x28(%rdi)
movb %al, 0x30(%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x40(%rdi)
movq %rax, 0x50(%rdi)
leaq 0x58(%rdi), %rcx
movq %rcx, -0x58(%rbp)
leaq 0x68(%rdi), %rcx
movq %rcx, -0x40(%rbp)
movq %rcx, 0x58(%rdi)
movq %rax, 0x60(%rdi)
movb %al, 0x68(%rdi)
leaq 0x78(%rdi), %r12
leaq 0x88(%rdi), %r14
movq %r14, 0x78(%rdi)
movq %rax, 0x80(%rdi)
movb %al, 0x88(%rdi)
leaq 0x98(%rdi), %r13
leaq 0xa8(%rdi), %r15
movq %r15, 0x98(%rdi)
movq %rax, 0xa0(%rdi)
movb %al, 0xa8(%rdi)
leaq 0x2db3(%rip), %rcx      # 0x6465
xorl %esi, %esi
xorl %edx, %edx
xorl %r8d, %r8d
callq 0x2260
movq 0x28(%rbx), %rdx
leaq 0x2d9c(%rip), %rcx      # 0x6465
movq -0x60(%rbp), %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x2260
leaq -0x78(%rbp), %rdi
leaq -0x29(%rbp), %rdx
movl $0x64, %esi
callq 0x455c
leaq -0x78(%rbp), %rdi
callq 0x3374
movq 0x60(%rbx), %rdx
leaq 0x2d68(%rip), %rcx      # 0x6465
movq -0x58(%rbp), %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x2260
movq 0x80(%rbx), %rdx
leaq 0x2d4c(%rip), %rcx      # 0x6465
movq %r12, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x2260
movq 0xa0(%rbx), %rdx
leaq 0x2d31(%rip), %rcx      # 0x6465
movq %r13, %rdi
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x2260
movl $0x0, 0xb8(%rbx)
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x375c
movq %rax, -0x38(%rbp)
movq (%r13), %rdi
cmpq %r15, %rdi
je 0x3774
movq (%r15), %rsi
incq %rsi
callq 0x2170
movq (%r12), %rdi
cmpq %r14, %rdi
je 0x3788
movq (%r14), %rsi
incq %rsi
callq 0x2170
leaq 0x40(%rbx), %r12
movq -0x58(%rbp), %rax
movq (%rax), %rdi
cmpq -0x40(%rbp), %rdi
je 0x37a8
movq -0x40(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x2170
movq %r12, %rdi
callq 0x3374
movq -0x60(%rbp), %rax
movq (%rax), %rdi
cmpq -0x48(%rbp), %rdi
je 0x37cc
movq -0x48(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x2170
movq (%rbx), %rdi
cmpq -0x50(%rbp), %rdi
je 0x37e4
movq -0x50(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x2170
movq -0x38(%rbp), %rdi
callq 0x22b0
nop
// File: /workspace/github_cpp_makefile_star2_O1/jmfenner92[P]Log-Parser/src/CmdRecord.cpp
// Function: CmdRecord::HexToBit(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
std::string CmdRecord::HexToBit(std::string hex_string)
{
	std::string bit_string = "";
	for (int i=0; i < hex_string.length(); ++i)
	{
		switch (hex_string [i])
		{
			case '0': bit_string.append ("0000"); break;
			case '1': bit_string.append ("0001"); break;
			case '2': bit_string.append ("0010"); break;
			case '3': bit_string.append ("0011"); break;
			case '4': bit_string.append ("0100"); break;
			case '5': bit_string.append ("0101"); break;
			case '6': bit_string.append ("0110"); break;
			case '7': bit_string.append ("0111"); break;
			case '8': bit_string.append ("1000"); break;
			case '9': bit_string.append ("1001"); break;
			case 'A': bit_string.append ("1010"); break;
			case 'B': bit_string.append ("1011"); break;
			case 'C': bit_string.append ("1100"); break;
			case 'D': bit_string.append ("1101"); break;
			case 'E': bit_string.append ("1110"); break;
			case 'F': bit_string.append ("1111"); break;
		}
	}
	return bit_string;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, -0x30(%rbp)
movq %rax, (%rdi)
leaq 0x2ad9(%rip), %rdx      # 0x6465
movq %rdx, %rsi
callq 0x3568
cmpq $0x0, 0x8(%r14)
je 0x39d9
xorl %r12d, %r12d
movl $0x7e03ff, %r13d        # imm = 0x7E03FF
leaq 0x27a1(%rip), %r15      # 0x614c
movq (%r14), %rax
movb (%rax,%r12), %al
addb $-0x30, %al
cmpb $0x17, %al
jae 0x39d0
movzbl %al, %eax
btl %eax, %r13d
jae 0x39d0
movslq (%r15,%rax,4), %rsi
addq %r15, %rsi
movq %rbx, %rdi
callq 0x22e0
incq %r12
cmpq %r12, 0x8(%r14)
ja 0x39ab
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq -0x30(%rbp), %rdi
je 0x3a06
movq -0x30(%rbp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x2170
movq %r14, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O1/jmfenner92[P]Log-Parser/src/CmdRecord.cpp
// Function: CmdRecord::lookAndAdd(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int)
int CmdRecord::lookAndAdd(std::string bitString, int startRange, int endRange) {
	int result = 0;
	std::string str = bitString.substr(startRange, endRange-startRange);
	int powerCounter = str.length() - 1;
	int indexCounter = 0;
	while(powerCounter != -1){
			if(str[indexCounter] == '0') {
				indexCounter++;
				powerCounter--;			
			}
			else {
				result += exp2(powerCounter);
				indexCounter++;
				powerCounter--;
			}
	}
	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movslq %edx, %rdx
subl %edx, %ecx
movslq %ecx, %rcx
leaq -0x38(%rbp), %rbx
movq %rbx, %rdi
callq 0x2190
movl 0x8(%rbx), %r14d
testl %r14d, %r14d
je 0x435f
decl %r14d
xorl %r15d, %r15d
xorl %ebx, %ebx
movq -0x38(%rbp), %rax
cmpb $0x30, (%rax,%r15)
je 0x4354
movsd 0x1e7b(%rip), %xmm0     # 0x61b8
movl %r14d, %edi
callq 0x2240
xorps %xmm1, %xmm1
cvtsi2sd %ebx, %xmm1
addsd %xmm0, %xmm1
cvttsd2si %xmm1, %ebx
incq %r15
addl $-0x1, %r14d
jb 0x432a
jmp 0x4361
xorl %ebx, %ebx
leaq -0x28(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x437a
movq -0x28(%rbp), %rsi
incq %rsi
callq 0x2170
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jmfenner92[P]Log-Parser/src/CmdRecord.cpp
// Function: CmdRecord::operator=(CmdRecord const&)
CmdRecord& CmdRecord::operator=(const CmdRecord &other)
{
	line_number = other.Get_Line_Number();
	address = other.Get_Address();
	data = other.Get_Data();
	size = other.Get_Size();
	cycle = other.Get_Cycle();
	reltime = other.Get_RelTime();
	wordsLength = other.Get_Total_Words();
	return *this;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x40(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%rsi), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x50(%rbp), %r15
movq %r15, %rdi
callq 0x34ce
movq %rbx, %rdi
movq %r15, %rsi
callq 0x21e0
movq (%r15), %rdi
cmpq %r13, %rdi
je 0x43dc
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2170
movq %r13, (%r15)
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x34ce
leaq 0x20(%rbx), %rdi
movq %r15, %rsi
callq 0x21e0
movq (%r15), %rdi
cmpq %r13, %rdi
je 0x4412
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2170
leaq 0x40(%r14), %rsi
leaq -0x68(%rbp), %r15
movq %r15, %rdi
callq 0x32e0
xorps %xmm0, %xmm0
leaq -0x50(%rbp), %r12
movaps %xmm0, (%r12)
movq $0x0, 0x10(%r12)
movq 0x40(%rbx), %rax
movups 0x48(%rbx), %xmm0
movq (%r15), %rcx
movq %rcx, 0x40(%rbx)
movq 0x8(%r15), %rcx
movq %rcx, 0x48(%rbx)
movq 0x10(%r15), %rcx
movq %rcx, 0x50(%rbx)
movq (%r12), %rcx
movq 0x8(%r12), %rdx
movq 0x10(%r12), %rsi
movq %rax, (%r12)
movups %xmm0, 0x8(%r12)
movq %rcx, (%r15)
movq %rdx, 0x8(%r15)
movq %rsi, 0x10(%r15)
movq %r12, %rdi
callq 0x3374
movq %r15, %rdi
callq 0x3374
movq %r13, (%r12)
movq 0x58(%r14), %rsi
movq 0x60(%r14), %rdx
addq %rsi, %rdx
leaq -0x50(%rbp), %r15
movq %r15, %rdi
callq 0x34ce
leaq 0x58(%rbx), %rdi
movq %r15, %rsi
callq 0x21e0
movq (%r15), %rdi
cmpq %r13, %rdi
je 0x44c4
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2170
movq %r13, (%r15)
movq 0x78(%r14), %rsi
movq 0x80(%r14), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x34ce
leaq 0x78(%rbx), %rdi
movq %r15, %rsi
callq 0x21e0
movq (%r15), %rdi
cmpq %r13, %rdi
je 0x44fd
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2170
movq %r13, (%r15)
movq 0x98(%r14), %rsi
movq 0xa0(%r14), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0x34ce
leaq 0x98(%rbx), %rdi
movq %r15, %rsi
callq 0x21e0
movq (%r15), %rdi
cmpq %r13, %rdi
je 0x453c
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x2170
movl 0xb8(%r14), %eax
movl %eax, 0xb8(%rbx)
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jmfenner92[P]Log-Parser/src/CmdList.cpp
// Function: CmdList::~CmdList()
CmdList::~CmdList()
{
	CmdNode *temp;
	CmdNode *current = head;

	while(current != NULL)
	{
		temp = current;
		current = current->next;
		delete temp;
	}
	
	head = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq (%rdi), %r14
testq %r14, %r14
je 0x48ab
movq 0xc0(%r14), %r15
movq %r14, %rdi
callq 0x3240
movl $0xc8, %esi
movq %r14, %rdi
callq 0x2170
movq %r15, %r14
testq %r15, %r15
jne 0x4887
movq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jmfenner92[P]Log-Parser/src/CmdList.cpp
// Function: CmdList::AddRecord(CmdRecord)
bool CmdList::AddRecord(CmdRecord record)
{
	// declare and initialize necessary variables
	CmdNode *current = head;
	CmdNode *temp_node;
	bool success = false;

	// initialize new Cmd_Node
	temp_node = new CmdNode;
	temp_node->info = record;
	temp_node->next = NULL;

	// check if list is empty
	if(head == NULL)
	{
		head = temp_node;
		success = true;
	}
	else // otherwise, loop till end and add new node
	{
		while(current->next != NULL)
		{
			current = current->next;
		}
		current->next = temp_node;
		success = true;
	}
	
	return success;	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
movq (%rdi), %r12
movl $0xc8, %edi
callq 0x2160
movq %rax, %rbx
movq %rax, %rdi
callq 0x3604
movq %rbx, %rdi
movq %r15, %rsi
callq 0x4388
movq $0x0, 0xc0(%rbx)
cmpq $0x0, (%r14)
je 0x491a
movq %r12, %r14
movq 0xc0(%r12), %r12
testq %r12, %r12
jne 0x4903
addq $0xc0, %r14
movq %rbx, (%r14)
movb $0x1, %al
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movl $0xc8, %esi
movq %rbx, %rdi
callq 0x2170
movq %r14, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O1/jmfenner92[P]Log-Parser/src/CmdList.cpp
// Function: CmdList::FindRecord(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const
bool CmdList::FindRecord(std::string line) const
{
	CmdNode *temp = head;
	bool	found = false;

	while(temp != NULL && !found)
	{
		if(temp->info.Get_Line_Number() == line)
		{
			found = true;
		}
		else
		{
			temp = temp->next;
		}
	}

	return found;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq (%rdi), %r15
testq %r15, %r15
je 0x49cd
movq %rsi, %r14
xorl %ebx, %ebx
leaq -0x48(%rbp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x37f8
movq -0x40(%rbp), %rdx
cmpq 0x8(%r14), %rdx
jne 0x4990
testq %rdx, %rdx
je 0x4995
movq (%r14), %rsi
movq -0x48(%rbp), %rdi
callq 0x2180
testl %eax, %eax
sete %r13b
jmp 0x4998
xorl %r13d, %r13d
jmp 0x4998
movb $0x1, %r13b
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x49b1
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2170
testb %r13b, %r13b
je 0x49ba
movb $0x1, %bl
jmp 0x49c1
movq 0xc0(%r15), %r15
testq %r15, %r15
je 0x49cf
testb $0x1, %bl
je 0x4962
jmp 0x49cf
xorl %ebx, %ebx
andb $0x1, %bl
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/jmfenner92[P]Log-Parser/src/CmdList.cpp
// Function: CmdList::RemoveRecord(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool CmdList::RemoveRecord(std::string line)
{
	CmdNode *previous;
	CmdNode *current = head;
	bool	success = false;

	// check if list is not empty
	if(current != NULL)
	{
		if(current->next == NULL)
		{
			delete current;
			head = NULL;
			success = true;
		}
		else
		{
			while(current != NULL && !success)
			{	
				if(current->info.Get_Line_Number() == line)
				{
					previous->next = current->next;
					delete current;
					success = true;
				}
				else
				{
					previous = current;
					current = current->next;
				}
			}
		}
	}

	return success;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq (%rdi), %rbx
testq %rbx, %rbx
je 0x4aa9
cmpq $0x0, 0xc0(%rbx)
je 0x4aae
movq %rsi, %r14
xorl %r15d, %r15d
leaq -0x48(%rbp), %rdi
movq %rbx, %rsi
callq 0x37f8
movq -0x40(%rbp), %rdx
cmpq 0x8(%r14), %rdx
jne 0x4a44
testq %rdx, %rdx
je 0x4a49
movq (%r14), %rsi
movq -0x48(%rbp), %rdi
callq 0x2180
testl %eax, %eax
sete %r12b
jmp 0x4a4c
xorl %r12d, %r12d
jmp 0x4a4c
movb $0x1, %r12b
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x4a65
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2170
movq 0xc0(%rbx), %rax
testb %r12b, %r12b
je 0x4a92
movq %rax, 0xc0(%r13)
movq %rbx, %rdi
callq 0x3240
movl $0xc8, %esi
movq %rbx, %rdi
callq 0x2170
movb $0x1, %r15b
jmp 0x4a98
movq %rbx, %r13
movq %rax, %rbx
testq %rbx, %rbx
je 0x4ad0
testb $0x1, %r15b
je 0x4a15
jmp 0x4ad0
xorl %r15d, %r15d
jmp 0x4ad0
movq %rdi, %r15
movq %rbx, %rdi
callq 0x3240
movl $0xc8, %esi
movq %rbx, %rdi
callq 0x2170
movq $0x0, (%r15)
movb $0x1, %r15b
andb $0x1, %r15b
movl %r15d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/jmfenner92[P]Log-Parser/src/CmdList.cpp
// Function: CmdList::PrintList() const
void CmdList::PrintList() const
{
	CmdNode *current = head;

	while(current != NULL)
	{
		std::cout << current->info.Get_Line_Number() << ": " << current->info.Get_Address() << "\n";
		current = current->next;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq (%rdi), %rbx
testq %rbx, %rbx
je 0x4bb5
leaq 0x1980(%rip), %r12      # 0x648a
leaq -0x48(%rbp), %r13
leaq 0x194f(%rip), %r14      # 0x6464
leaq -0x68(%rbp), %rdi
movq %rbx, %rsi
callq 0x37f8
movq -0x68(%rbp), %rsi
movq -0x60(%rbp), %rdx
movq 0x44a0(%rip), %rdi      # 0x8fd0
callq 0x21c0
movq %rax, %r15
movl $0x2, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x21c0
movq %r13, %rdi
movq %rbx, %rsi
callq 0x3832
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdx
movq %r15, %rdi
callq 0x21c0
movl $0x1, %edx
movq %rax, %rdi
movq %r14, %rsi
callq 0x21c0
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x4b8c
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2170
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x4ba5
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x2170
movq 0xc0(%rbx), %rbx
testq %rbx, %rbx
jne 0x4b15
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4bc6
movq %rax, %rbx
jmp 0x4be7
movq %rax, %rbx
movq -0x48(%rbp), %rdi
leaq -0x38(%rbp), %rax
cmpq %rax, %rdi
je 0x4be7
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x2170
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x4c00
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x2170
movq %rbx, %rdi
callq 0x22b0
// File: /workspace/github_cpp_makefile_star2_O1/andyn[P]libdlmm/./dlmm.hh
// Function: int& Dl::symbol<int>(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>> const&) const
T &symbol(std::string const &symbol_name) const {
        // Convert a void pointer to a function pointer without warnings.
        // Since we're type punning, make sure that pointer sizes do not differ.
        assert(sizeof(void *) == sizeof(void (*)()));
        union {
            void *m_void;
            T *m_real;
        } ptr;

        ptr.m_void = dlsym(m_library, symbol_name.c_str());
        if (ptr.m_void == nullptr)
            throw std::runtime_error(
                std::string("Dl::symbol(\"" + symbol_name + "\"): ") +
                dlerror());

        return *ptr.m_real;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rsi, %r14
movq (%rdi), %rdi
movq (%rsi), %rsi
callq 0x2130
testq %rax, %rax
je 0x2fba
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movl $0x10, %edi
callq 0x20a0
movq %rax, %rbx
leaq 0x138f(%rip), %rsi      # 0x435d
leaq 0x40(%rsp), %rdi
movq %r14, %rdx
callq 0x352d
leaq 0x134c(%rip), %rsi      # 0x432e
leaq 0x40(%rsp), %rdi
callq 0x2240
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x300d
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x3019
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
movq 0x8(%rax), %rdx
movq %rsp, %r14
movq %rdx, 0x8(%r14)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
callq 0x2140
movq %r14, %rdi
movq %rax, %rsi
callq 0x2240
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x3066
movups (%rcx), %xmm0
movups %xmm0, (%r12)
jmp 0x3073
movq %rdx, 0x20(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x30(%rsp)
movq 0x8(%rax), %rdx
leaq 0x20(%rsp), %rsi
movq %rdx, 0x8(%rsi)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movb $0x1, %bpl
movq %rbx, %rdi
callq 0x21e0
xorl %ebp, %ebp
movq 0x2f4d(%rip), %rsi      # 0x5ff0
movq 0x2f16(%rip), %rdx      # 0x5fc0
movq %rbx, %rdi
callq 0x2200
movq %rax, %r14
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x30d4
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x2160
jmp 0x30d4
movq %rax, %r14
movb $0x1, %bpl
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x30f2
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2160
jmp 0x30f2
movq %rax, %r14
movb $0x1, %bpl
leaq 0x50(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x3115
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x2160
jmp 0x3115
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x3122
movq %rbx, %rdi
callq 0x20f0
movq %r14, %rdi
callq 0x2220
// File: /workspace/github_cpp_makefile_star2_O1/cmirnov[P]triangular-arbitrage/convert.cpp
// Function: Converter::intToName[abi:cxx11](int)
std::string Converter::intToName(int num) {
	if (num >= currencies.size()) {
		printf("out of range currency number\n");
		return NULL;
	} else {
		return currencies[num];
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movslq %edx, %rax
movq (%rsi), %rcx
movq 0x8(%rsi), %rdx
subq %rcx, %rdx
sarq $0x5, %rdx
leaq 0x10(%rdi), %r14
cmpq %rax, %rdx
jbe 0x4197
shlq $0x5, %rax
movq %r14, (%rbx)
movq (%rcx,%rax), %rsi
movq 0x8(%rcx,%rax), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x32a2
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x1f46(%rip), %rdi      # 0x60e4
callq 0x21b0
movq %r14, (%rbx)
leaq 0x1e8b(%rip), %rdi      # 0x6038
callq 0x20d0
// File: /workspace/github_cpp_makefile_star2_O1/cmirnov[P]triangular-arbitrage/convert.cpp
// Function: Converter::nameToInt(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int Converter::nameToInt(std::string name) {
	for (int i = 0; i < currencies.size(); ++i) {
		if (currencies[i] == name) {
			return i;
		}
	}
	printf("no such currency in the list\n");
	return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, -0x30(%rbp)
movq (%rdi), %r15
movq 0x8(%rdi), %rbx
subq %r15, %rbx
setne %r13b
je 0x4239
sarq $0x5, %rbx
movq -0x30(%rbp), %rax
movq 0x8(%rax), %rax
cmpq $0x1, %rbx
movq %rbx, %r12
adcq $0x0, %r12
addq $0x8, %r15
xorl %r14d, %r14d
movq %rax, -0x38(%rbp)
movq (%r15), %rdx
cmpq %rax, %rdx
jne 0x421e
testq %rdx, %rdx
je 0x4233
movq -0x30(%rbp), %rax
movq (%rax), %rsi
movq -0x8(%r15), %rdi
callq 0x2160
testl %eax, %eax
movq -0x38(%rbp), %rax
je 0x4233
incq %r14
cmpq %r14, %rbx
seta %r13b
addq $0x20, %r15
cmpq %r14, %r12
jne 0x41f9
jmp 0x4239
testb $0x1, %r13b
jne 0x424b
leaq 0x1ec1(%rip), %rdi      # 0x6101
callq 0x21b0
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
movl %r14d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/cmirnov[P]triangular-arbitrage/orderbook.cpp
// Function: Orderbook::update()
void Orderbook::update() { 
	std::random_device rd;
    std::mt19937 gen(rd());
    std::uniform_real_distribution<> disPrice(0.03, 30.0);
    std::uniform_real_distribution<> disAmount(100.0, 3000.0);
	for (int i = 0; i < 10; ++i) {
		long double amount = disAmount(gen);
		long double price = disPrice(gen);
		table.push_back(new Column(amount, price));	
	}
	sort(table.begin(), table.end(), [](Column *a, Column *b) {return a->price < b->price;});
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x2740, %rsp           # imm = 0x2740
movq %rdi, %rbx
leaq -0x2760(%rbp), %r14
movq %r14, %rdi
callq 0x4a94
movq %r14, %rdi
callq 0x2180
movl %eax, %eax
movq %rax, -0x13d8(%rbp)
movl $0x1, %ecx
movq %rax, %rdx
shrq $0x1e, %rdx
xorl %eax, %edx
imull $0x6c078965, %edx, %eax # imm = 0x6C078965
addl %ecx, %eax
movq %rax, -0x13d8(%rbp,%rcx,8)
incq %rcx
cmpq $0x270, %rcx            # imm = 0x270
jne 0x458e
leaq -0x13d8(%rbp), %r14
movq $0x270, 0x1380(%r14) # imm = 0x270
movl $0xa, %r12d
leaq -0x40(%rbp), %r15
movq %r14, %rdi
callq 0x4bab
mulsd 0x1b41(%rip), %xmm0     # 0x6120
addsd 0x1b41(%rip), %xmm0     # 0x6128
movsd %xmm0, -0x38(%rbp)
fldl -0x38(%rbp)
fstpt -0x4c(%rbp)
movq %r14, %rdi
callq 0x4bab
movsd %xmm0, -0x28(%rbp)
movl $0x20, %edi
callq 0x2140
movsd -0x28(%rbp), %xmm0
mulsd 0x1b1a(%rip), %xmm0     # 0x6130
addsd 0x1b1a(%rip), %xmm0     # 0x6138
movsd %xmm0, -0x30(%rbp)
fldl -0x30(%rbp)
fldt -0x4c(%rbp)
fstpt (%rax)
fstpt 0x10(%rax)
movq %rax, -0x40(%rbp)
movq 0x8(%rbx), %rsi
cmpq 0x10(%rbx), %rsi
je 0x4646
movq %rax, (%rsi)
addq $0x8, 0x8(%rbx)
jmp 0x4651
movq %rbx, %rdi
movq %r15, %rdx
callq 0x4e1c
decl %r12d
jne 0x45cf
movq (%rbx), %r15
movq 0x8(%rbx), %rbx
cmpq %rbx, %r15
je 0x46ee
movq %rbx, %r14
subq %r15, %r14
movq %r14, %rax
sarq $0x3, %rax
bsrq %rax, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x4761
cmpq $0x81, %r14
jl 0x46e3
leaq 0x80(%r15), %r14
movq %r15, %rdi
movq %r14, %rsi
callq 0x49fd
cmpq %rbx, %r14
je 0x46ee
movq -0x8(%r14), %rcx
movq (%r14), %rax
fldt 0x10(%rax)
fldt 0x10(%rcx)
fucompi %st(1), %st
movq %r14, %rdx
jbe 0x46d8
movq %r14, %rdx
movq %rcx, (%rdx)
movq -0x10(%rdx), %rcx
fldt 0x10(%rcx)
addq $-0x8, %rdx
fucompi %st(1), %st
ja 0x46c6
fstp %st(0)
movq %rax, (%rdx)
addq $0x8, %r14
jmp 0x46aa
movq %r15, %rdi
movq %rbx, %rsi
callq 0x49fd
leaq -0x2760(%rbp), %rdi
callq 0x2120
addq $0x2740, %rsp           # imm = 0x2740
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4729
jmp 0x4712
jmp 0x4712
jmp 0x4712
movq %rax, %rbx
leaq -0x2760(%rbp), %rdi
callq 0x2120
movq %rbx, %rdi
callq 0x21f0
movq %rax, %rdi
callq 0x3293
nop
// File: /workspace/github_cpp_makefile_star2_O1/cmirnov[P]triangular-arbitrage/orderbook.cpp
// Function: Orderbook::get(int)
Column* Orderbook::get(int idx) {
	if (idx >= table.size()) {
		printf("out of range of orderbook\n");
		return NULL;
	}
	return table[idx];
}

// Assembly:
movslq %esi, %rax
movq (%rdi), %rcx
movq 0x8(%rdi), %rdx
subq %rcx, %rdx
sarq $0x3, %rdx
cmpq %rax, %rdx
jbe 0x474d
movq (%rcx,%rax,8), %rax
retq
pushq %rbp
movq %rsp, %rbp
leaq 0x1a30(%rip), %rdi      # 0x6188
callq 0x21b0
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/AndreyVV-100[P]GachiLang/Frontend/Frontend.cpp
// Function: main
int main (int argc, const char** argv)
{
    if (argc < 2)
    {
        printf ("Error: No file name input.\n");
        return 0;
    }

    Tree code = {};
    TreeConstructor (&code);

    if (GoTree (&code, argv[1]) == 0)
        SaveTree (&code);

    TreeDestructor (&code);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
cmpl $0x1, %edi
jg 0x12aa
leaq 0x3140(%rip), %rdi      # 0x43e3
callq 0x1160
jmp 0x130e
movq %rsi, %rbx
leaq -0x60(%rbp), %r14
movq $0x0, (%r14)
movabsq $-0x452212e21844f85f, %rax # imm = 0xBADDED1DE7BB07A1
movq %rax, 0x8(%r14)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r14)
movups %xmm0, 0x20(%r14)
movl $0xc, 0x30(%r14)
movups %xmm0, 0x38(%r14)
movq %rax, 0x48(%r14)
movq %r14, %rdi
callq 0x28e0
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x1319
testb %al, %al
jne 0x1305
leaq -0x60(%rbp), %rdi
callq 0x2d85
leaq -0x60(%rbp), %rdi
callq 0x291d
xorl %eax, %eax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/AndreyVV-100[P]GachiLang/Frontend/Frontend.cpp
// Function: GoTree(Tree*, char const*)
bool GoTree (Tree* tree, const char* file_path)
{
    assert (tree);
    assert (file_path);
    
    if (LexicalAnalyze (tree, file_path))
        return 1;

    if (LexicalParse (tree))
        return 1;

    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x134c
testq %rsi, %rsi
je 0x136b
movq %rdi, %rbx
callq 0x138a
testb %al, %al
je 0x133e
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x14ac
leaq 0x2cb1(%rip), %rdi      # 0x4004
leaq 0x2caf(%rip), %rsi      # 0x4009
leaq 0x2cbe(%rip), %rcx      # 0x401f
movl $0x19, %edx
callq 0x1090
leaq 0x2ccf(%rip), %rdi      # 0x4041
leaq 0x2c90(%rip), %rsi      # 0x4009
leaq 0x2c9f(%rip), %rcx      # 0x401f
movl $0x1a, %edx
callq 0x1090