LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/anuwu[P]ERPLAG-Compiler/parser.c
// Function: traverse_grammar
void traverse_grammar()
{
	for(int i=0;i<150;i++)
	{
		for(int j=0;j<150;j++)
		{
			parsetable[i][j]=-1;
		}
	}	

	for(int i=0;i<rule_count;i++)
	{
		int lhs_enum_value=rule[i].LHS;
		node* temp=rule[i].RHS;


		// NT -> eps 
		if(temp->key==TK_EPS)
		{
			node* temp3=follows[lhs_enum_value];
			while(temp3!=NULL)
			{
				parsetable[lhs_enum_value][temp3->key]=i;
				temp3=temp3->next;
			}
			continue;
		}	

		// traversing on rhs T/NT sequentially	
		while(temp!=NULL)
		{	
			// temp2 is Terminals in first of T/NT
			node* temp2=firsts[temp->key];

			int flag=0;
			while(temp2!=NULL)
			{
				if(temp2->key!=TK_EPS)
					parsetable[lhs_enum_value][temp2->key]=i;
				else
					flag=1;

				temp2=temp2->next;
			}

			if(flag==0)
				break;
			else // haven't encountered eps yet so keep filling by next T/NT's first
				temp=temp->next;

		}

		if(temp==NULL)
		{
			// all firsts are consumed and all are nullable
			node* temp3=follows[lhs_enum_value];
			while(temp3!=NULL)
			{
				parsetable[lhs_enum_value][temp3->key]=i;
				temp3=temp3->next;
			}
		}
		
	}	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0xfc39(%rip), %rbx      # 0x1a770
movl $0x15f90, %edx          # imm = 0x15F90
movq %rbx, %rdi
movl $0xff, %esi
callq 0x10c0
movslq 0x25bb0(%rip), %rax     # 0x30700
testq %rax, %rax
jle 0xac45
xorl %ecx, %ecx
leaq 0x25bae(%rip), %rdx     # 0x30710
leaq 0x26827(%rip), %rsi     # 0x31390
leaq 0x26e60(%rip), %rdi     # 0x319d0
movq %rcx, %r9
shlq $0x4, %r9
movslq (%r9,%rdx), %r8
movq 0x8(%r9,%rdx), %r9
cmpl $0x36, (%r9)
jne 0xabb2
movq (%rsi,%r8,8), %r9
testq %r9, %r9
je 0xac39
imulq $0x258, %r8, %r8        # imm = 0x258
addq %rbx, %r8
movl (%r9), %r10d
movl %ecx, (%r8,%r10,4)
movq 0x8(%r9), %r9
testq %r9, %r9
jne 0xab9d
jmp 0xac39
testq %r9, %r9
je 0xac0e
movl (%r9), %r10d
movq (%rdi,%r10,8), %r10
testq %r10, %r10
je 0xabfb
xorl %r11d, %r11d
movl (%r10), %r15d
movl $0x1, %r14d
cmpq $0x36, %r15
je 0xabe6
imulq $0x258, %r8, %r14       # imm = 0x258
addq %rbx, %r14
movl %ecx, (%r14,%r15,4)
movl %r11d, %r14d
movq 0x8(%r10), %r10
movl %r14d, %r11d
testq %r10, %r10
jne 0xabc6
testl %r14d, %r14d
sete %r10b
jmp 0xabfe
movb $0x1, %r10b
testb %r10b, %r10b
jne 0xac07
movq 0x8(%r9), %r9
testb %r10b, %r10b
je 0xabb2
jmp 0xac11
xorl %r9d, %r9d
testq %r9, %r9
jne 0xac39
movq (%rsi,%r8,8), %r9
testq %r9, %r9
je 0xac39
imulq $0x258, %r8, %r8        # imm = 0x258
addq %rbx, %r8
movl (%r9), %r10d
movl %ecx, (%r8,%r10,4)
movq 0x8(%r9), %r9
testq %r9, %r9
jne 0xac29
incq %rcx
cmpq %rax, %rcx
jne 0xab70
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/anuwu[P]ERPLAG-Compiler/parser.c
// Function: addUniquely
void addUniquely(tokenID target, tokenID insert_it)
{
	//Target linked list should never be empty
	node * tmp_target = firsts[target];

	if(tmp_target->key != insert_it){
		while( 1){

			if(tmp_target->next ==  NULL){
				tmp_target->next = initnode(insert_it);
				return;
			}
			else if(tmp_target->next->key == insert_it){
				return;
			}
			tmp_target = tmp_target->next;
		}
		// else we need not to do anything because its already there
	}
	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edi, %eax
leaq 0x26d70(%rip), %rcx     # 0x319d0
movq (%rcx,%rax,8), %r14
cmpl %esi, (%r14)
je 0xac95
movl %esi, %ebx
movq 0x8(%r14), %rax
testq %rax, %rax
je 0xac7d
movq %rax, %r14
cmpl %ebx, (%rax)
jne 0xac6b
jmp 0xac95
movl $0x10, %edi
callq 0x1120
movl %ebx, (%rax)
movq $0x0, 0x8(%rax)
movq %rax, 0x8(%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/anuwu[P]ERPLAG-Compiler/parser.c
// Function: addUniquelyFollow
void addUniquelyFollow(tokenID target, tokenID insert_it){
	//Target linked list should never be empty
	node * tmp_target = follows[target];

	if(tmp_target->key != insert_it){
		while( 1){

			if(tmp_target->next ==  NULL){
				tmp_target->next = initnode(insert_it);
				return;
			}
			else if(tmp_target->next->key == insert_it){
				return;
			}
			tmp_target = tmp_target->next;
		}
		// else we need not to do anything because its already there
	}
	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edi, %eax
leaq 0x266e6(%rip), %rcx     # 0x31390
movq (%rcx,%rax,8), %r14
cmpl %esi, (%r14)
je 0xacdf
movl %esi, %ebx
movq 0x8(%r14), %rax
testq %rax, %rax
je 0xacc7
movq %rax, %r14
cmpl %ebx, (%rax)
jne 0xacb5
jmp 0xacdf
movl $0x10, %edi
callq 0x1120
movl %ebx, (%rax)
movq $0x0, 0x8(%rax)
movq %rax, 0x8(%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/anuwu[P]ERPLAG-Compiler/parser.c
// Function: unionFirst
void unionFirst(tokenID target, tokenID source){
	node * sourceLL = firsts[source];
	node * tmp_target = firsts[target];

	if(sourceLL == NULL)
		return;

	// when target was initially empty
	if(tmp_target == NULL){
		firsts[target] = initnode(sourceLL->key);

		node * tmp = firsts[target] ;
		sourceLL = sourceLL->next ;
		while(sourceLL){

			if(sourceLL->key != TK_EPS){
				tmp->next = initnode(sourceLL->key);
				tmp = tmp->next;
				
			}
			
			sourceLL = sourceLL->next;
		}
	}
	else {
		// when target is initially not empty

		while(sourceLL!=NULL){
			tokenID need_to_insert = sourceLL->key;	

			if(need_to_insert != TK_EPS)	
				addUniquely(target,need_to_insert);

			sourceLL = sourceLL->next;
		}
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %eax
leaq 0x26cd5(%rip), %r15     # 0x319d0
movq (%r15,%rax,8), %r14
testq %r14, %r14
je 0xad80
movl %edi, %ebx
movl %edi, %r12d
cmpq $0x0, (%r15,%r12,8)
je 0xad2a
movl (%r14), %esi
cmpl $0x36, %esi
je 0xad1f
movl %ebx, %edi
callq 0xac50
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0xad10
jmp 0xad80
movl (%r14), %r13d
movl $0x10, %edi
callq 0x1120
movl %r13d, (%rax)
movq $0x0, 0x8(%rax)
movq %rax, (%r15,%r12,8)
movq 0x8(%r14), %r14
testq %r14, %r14
je 0xad80
movq %rax, %rbx
movl (%r14), %r15d
cmpl $0x36, %r15d
je 0xad77
movl $0x10, %edi
callq 0x1120
movl %r15d, (%rax)
movq $0x0, 0x8(%rax)
movq %rax, 0x8(%rbx)
movq %rax, %rbx
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0xad52
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/anuwu[P]ERPLAG-Compiler/parser.c
// Function: containsEpsilon
int containsEpsilon(tokenID id)
{
	node* tmp = firsts[id];
	while(tmp){
		if(tmp->key == TK_EPS)
			return 1;
		tmp = tmp->next ;
	}
	return 0;
}

// Assembly:
movl %edi, %eax
leaq 0x26c38(%rip), %rcx     # 0x319d0
movq (%rcx,%rax,8), %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0xadbd
pushq %rbp
movq %rsp, %rbp
cmpl $0x36, (%rcx)
je 0xadb7
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
jne 0xada7
jmp 0xadbc
movl $0x1, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/anuwu[P]ERPLAG-Compiler/parser.c
// Function: populateFirst
void populateFirst (tokenID id)
{
	if(isTerminal(id))
		return;

	location* ruleLoc ;
	node* rRHS ;
	Rule r ;
	int rule_index ;
	ruleLoc = &heads[id] ;

	while (ruleLoc != NULL)
	{		
		rule_index = ruleLoc->ind ;
		r = rule[rule_index] ;
		rRHS = r.RHS ;

		// recursive call to fill all empty RHSs
		while(rRHS != NULL)
		{
			if (firsts[rRHS->key] == NULL)
				populateFirst (rRHS->key) ;

			unionFirst (id, rRHS->key) ;

			if (containsEpsilon(rRHS->key))
				rRHS = rRHS->next ;
			else
				break ;
		}

		if (rRHS == NULL)
			addUniquely (id, TK_EPS) ;

		ruleLoc = ruleLoc->next ;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebx
leal -0x36(%rbx), %eax
cmpl $0x3d, %eax
jb 0xae53
movl %ebx, %eax
shlq $0x4, %rax
leaq 0xd59d(%rip), %r14      # 0x18380
addq %rax, %r14
leaq 0x25923(%rip), %r15     # 0x30710
leaq 0x26bdc(%rip), %r12     # 0x319d0
movslq (%r14), %rax
shlq $0x4, %rax
movq 0x8(%rax,%r15), %r13
testq %r13, %r13
je 0xae3e
movl (%r13), %edi
cmpq $0x0, (%r12,%rdi,8)
jne 0xae15
callq 0xadbe
movl (%r13), %esi
movl %ebx, %edi
callq 0xace4
movl (%r13), %eax
movq (%r12,%rax,8), %rax
testq %rax, %rax
je 0xae4a
cmpl $0x36, (%rax)
je 0xae38
movq 0x8(%rax), %rax
jmp 0xae28
movq 0x8(%r13), %r13
jmp 0xae00
movl %ebx, %edi
movl $0x36, %esi
callq 0xac50
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0xadf4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/anuwu[P]ERPLAG-Compiler/parser.c
// Function: printFollowSet
void printFollowSet (tokenID id)
{
	node* tmp = follows[id] ;
	if (tmp == NULL)
	 	printf ("Empty follow set\n") ;
	else
	{
	 while (tmp != NULL)
	 {
		 printf ("%d, ", tmp->key) ;
		 tmp = tmp->next ;
	 }
	 endl ;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edi, %eax
leaq 0x2651e(%rip), %rcx     # 0x31390
movq (%rcx,%rax,8), %r14
testq %r14, %r14
je 0xaea6
leaq 0x7518(%rip), %rbx      # 0x1239a
movl (%r14), %esi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x10b0
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0xae82
movl $0xa, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x1040
leaq 0x75ef(%rip), %rdi      # 0x1249c
popq %rbx
popq %r14
popq %rbp
jmp 0x1070
// File: /workspace/github_c_makefile_star2_O1/anuwu[P]ERPLAG-Compiler/parser.c
// Function: populateFollow
void populateFollow (tokenID id)
{
	int rule_index ;

	for (rule_index = 0 ; rule_index < rule_count ; rule_index++)
	{

		tokenID current_rule_lhs = (tokenID) rule[rule_index].LHS;
		node * tmp_of_rhs_of_current_rule = rule[rule_index].RHS;

		while(tmp_of_rhs_of_current_rule != NULL)
		{		
			if(tmp_of_rhs_of_current_rule->key == id)
			{ // if my key is id

				if(tmp_of_rhs_of_current_rule->next == NULL)
				{ // i am last element of this rule

					if(follows[current_rule_lhs] == NULL)
						populateFollow(current_rule_lhs);

					if (id != current_rule_lhs)
						unionFollow (id, current_rule_lhs) ;
				}
				else
				{

					if(containsEpsilon(tmp_of_rhs_of_current_rule->next->key))
					{ // next can go to null firsts[next] contains eps
		
						node * tmp = tmp_of_rhs_of_current_rule->next;
						while(tmp!=NULL && containsEpsilon(tmp->key))
						{
							UnionFollowFirst(id,tmp->key);
							tmp = tmp->next;
						}
						// while can exit either tmp == NULL
						if(tmp == NULL)
						{
							if(follows[current_rule_lhs] == NULL)
								populateFollow(current_rule_lhs);

							unionFollow(id,current_rule_lhs);
						}
						else
							UnionFollowFirst(id,tmp->key);

					}
					else
						UnionFollowFirst(id,tmp_of_rhs_of_current_rule->next->key);
					
				}
			}
			tmp_of_rhs_of_current_rule = tmp_of_rhs_of_current_rule->next;
		}
	}
}

// Assembly:
cmpl $0x0, 0x25843(%rip)     # 0x30700
jle 0xafd7
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebx
xorl %r15d, %r15d
movq %r15, %rax
shlq $0x4, %rax
leaq 0x2582c(%rip), %rcx     # 0x30710
movq 0x8(%rax,%rcx), %r13
testq %r13, %r13
je 0xafb6
leaq 0x25817(%rip), %rcx     # 0x30710
movl (%rax,%rcx), %r14d
cmpl %ebx, (%r13)
jne 0xafa9
movq 0x8(%r13), %rax
testq %rax, %rax
je 0xaf2d
movl (%rax), %esi
leaq 0x26ab7(%rip), %rax     # 0x319d0
movq (%rax,%rsi,8), %rax
testq %rax, %rax
je 0xaf80
cmpl $0x36, (%rax)
je 0xaf4a
movq 0x8(%rax), %rax
jmp 0xaf1d
leaq 0x2645c(%rip), %rax     # 0x31390
cmpq $0x0, (%rax,%r14,8)
jne 0xaf43
movl %r14d, %edi
callq 0xaeb6
cmpl %ebx, %r14d
jne 0xaf9f
jmp 0xafa9
movq 0x8(%r13), %r12
testq %r12, %r12
je 0xaf89
movl (%r12), %esi
leaq 0x26a72(%rip), %rax     # 0x319d0
movq (%rax,%rsi,8), %rax
testq %rax, %rax
je 0xaf80
cmpl $0x36, (%rax)
je 0xaf72
movq 0x8(%rax), %rax
jmp 0xaf62
movl %ebx, %edi
callq 0xb078
movq 0x8(%r12), %r12
jmp 0xaf4e
movl %ebx, %edi
callq 0xb078
jmp 0xafa9
leaq 0x26400(%rip), %rax     # 0x31390
cmpq $0x0, (%rax,%r14,8)
jne 0xaf9f
movl %r14d, %edi
callq 0xaeb6
movl %ebx, %edi
movl %r14d, %esi
callq 0xafd8
movq 0x8(%r13), %r13
testq %r13, %r13
jne 0xaefd
incq %r15
movslq 0x25740(%rip), %rax     # 0x30700
cmpq %rax, %r15
jl 0xaed6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/anuwu[P]ERPLAG-Compiler/parser.c
// Function: unionFollow
void unionFollow(tokenID target, tokenID source){
	node * sourceLL = follows[source];
	node * tmp_target = follows[target];

	if(sourceLL == NULL)
		return;

	// when target was initially empty
	if(tmp_target == NULL){
		follows[target] = initnode(sourceLL->key);

		node * tmp = follows[target] ;
		sourceLL = sourceLL->next ;
		while(sourceLL){
			tmp->next = initnode(sourceLL->key);
			tmp = tmp->next ;
			sourceLL = sourceLL->next;
		}
	}
	else {
		// when target is initially not empty

		while(sourceLL!=NULL){
			tokenID need_to_insert = sourceLL->key;	
			addUniquelyFollow(target,need_to_insert);
			sourceLL = sourceLL->next;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %eax
leaq 0x263a1(%rip), %r15     # 0x31390
movq (%r15,%rax,8), %r14
testq %r14, %r14
je 0xb069
movl %edi, %ebx
movl %edi, %r12d
cmpq $0x0, (%r15,%r12,8)
je 0xb019
movl (%r14), %esi
movl %ebx, %edi
callq 0xac9a
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0xb004
jmp 0xb069
movl (%r14), %r13d
movl $0x10, %edi
callq 0x1120
movl %r13d, (%rax)
movq $0x0, 0x8(%rax)
movq %rax, (%r15,%r12,8)
movq 0x8(%r14), %r14
testq %r14, %r14
je 0xb069
movq %rax, %rbx
movl (%r14), %r15d
movl $0x10, %edi
callq 0x1120
movl %r15d, (%rax)
movq $0x0, 0x8(%rax)
movq %rax, 0x8(%rbx)
movq 0x8(%r14), %r14
movq %rax, %rbx
testq %r14, %r14
jne 0xb041
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/anuwu[P]ERPLAG-Compiler/parser.c
// Function: UnionFollowFirst
void UnionFollowFirst (tokenID target, tokenID source)
 {
	node * sourceLL = firsts[source];
	node * tmp_target = follows[target];

	if(sourceLL == NULL)
		return;

	// when target was initially empty
	if(tmp_target == NULL){
		follows[target] = initnode(sourceLL->key);

		node * tmp = follows[target] ;
		sourceLL = sourceLL->next ;
		while(sourceLL){

			if(sourceLL->key != TK_EPS){
				tmp->next = initnode(sourceLL->key);
				tmp = tmp->next;	
			}
			
			sourceLL = sourceLL->next;
		}
	}
	else {
		// when target is initially not empty
		while(sourceLL!=NULL){
			tokenID need_to_insert = sourceLL->key;	

			if(need_to_insert != TK_EPS)	
				addUniquelyFollow(target,need_to_insert);

			sourceLL = sourceLL->next;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %eax
leaq 0x26941(%rip), %rcx     # 0x319d0
movq (%rcx,%rax,8), %r14
testq %r14, %r14
je 0xb11f
movl %edi, %ebx
movl %edi, %r15d
leaq 0x262e8(%rip), %r12     # 0x31390
cmpq $0x0, (%r12,%r15,8)
je 0xb0c9
movl (%r14), %esi
cmpl $0x36, %esi
je 0xb0be
movl %ebx, %edi
callq 0xac9a
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0xb0af
jmp 0xb11f
movl (%r14), %r13d
movl $0x10, %edi
callq 0x1120
movl %r13d, (%rax)
movq $0x0, 0x8(%rax)
movq %rax, (%r12,%r15,8)
movq 0x8(%r14), %r14
testq %r14, %r14
je 0xb11f
movq %rax, %rbx
movl (%r14), %r15d
cmpl $0x36, %r15d
je 0xb116
movl $0x10, %edi
callq 0x1120
movl %r15d, (%rax)
movq $0x0, 0x8(%rax)
movq %rax, 0x8(%rbx)
movq %rax, %rbx
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0xb0f1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/anuwu[P]ERPLAG-Compiler/parser.c
// Function: create_node
treeNode* create_node (nodeTag tag, TNT tnt)
{
	treeNode *node = (treeNode *) malloc (sizeof(treeNode)) ;

	node->tag = tag ;
 
	node->tnt = tnt ;
	node->child = NULL ;
	node->next = NULL ;
	node->parent = NULL ;


	node->gcode = -5 ; // default value ( should be replaced )
	node->syn = NULL ;
	node->inh = NULL ;

	return node ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl %edi, %r14d
movl $0x40, %edi
callq 0x1120
movl %r14d, (%rax)
movq %rbx, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rax)
movq $0x0, 0x38(%rax)
movl $0xfffffffb, 0x20(%rax) # imm = 0xFFFFFFFB
movups %xmm0, 0x10(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/anuwu[P]ERPLAG-Compiler/parser.c
// Function: add_child
void add_child (treeNode *parent, treeNode *node)
{
	if (parent->child == NULL)
		parent->child = node ;
	else
	{
		treeNode *ptr ;
		ptr = parent->child ;
		while (ptr->next != NULL)
			ptr = ptr->next ;
 
		ptr->next = node ;
	}
 
	node->parent = parent ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x28(%rdi), %rcx
testq %rcx, %rcx
je 0xb4bb
movq %rcx, %rax
movq 0x30(%rcx), %rcx
testq %rcx, %rcx
jne 0xb4a9
addq $0x30, %rax
jmp 0xb4bf
leaq 0x28(%rdi), %rax
movq %rsi, (%rax)
movq %rdi, 0x38(%rsi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/anuwu[P]ERPLAG-Compiler/parser.c
// Function: print_node
void print_node (treeNode *node)
{
	if (node->tag == TERMINAL)
		printf ("%d %d %s %d", node->tag, node->tnt.term->id, node->tnt.term->lexeme, node->tnt.term->lineNumber) ;
	else if (node->tag == NON_TERMINAL)
		printf ("%d %d", node->tag, node->tnt.nonTerm) ;
	else
		printf ("INVALID ENUM\n") ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl (%rdi), %eax
cmpl $0x1, %eax
je 0xb4f6
testl %eax, %eax
jne 0xb50d
movq 0x8(%rdi), %rax
movl (%rax), %edx
movq 0x8(%rax), %rcx
movl 0x10(%rax), %r8d
leaq 0x6f1b(%rip), %rdi      # 0x12407
xorl %esi, %esi
xorl %eax, %eax
popq %rbp
jmp 0x10b0
movl 0x8(%rdi), %edx
leaq 0x6f13(%rip), %rdi      # 0x12413
movl $0x1, %esi
xorl %eax, %eax
popq %rbp
jmp 0x10b0
leaq 0x6f99(%rip), %rdi      # 0x124ad
popq %rbp
jmp 0x1070
// File: /workspace/github_c_makefile_star2_O1/anuwu[P]ERPLAG-Compiler/parser.c
// Function: print_siblings
void print_siblings (treeNode *node)
{
	treeNode *ptr ;
	printf ("---------------\n") ;
 
	ptr = node ;
	while (ptr != NULL)
	{
		print_node (ptr) ;
		printf("\n") ;
		ptr = ptr->next ;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x6f90(%rip), %rdi      # 0x124ba
callq 0x1070
testq %rbx, %rbx
je 0xb54c
movq %rbx, %rdi
callq 0xb4c8
movl $0xa, %edi
callq 0x1040
movq 0x30(%rbx), %rbx
jmp 0xb52f
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/anuwu[P]ERPLAG-Compiler/parser.c
// Function: initStack
stacknode * initStack(){
	stacknode * head = (stacknode* ) malloc(sizeof(stacknode));
	head->key = TK_EOF;
	head->next = NULL;
 
	return head;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x10, %edi
callq 0x1120
movl $0x70, (%rax)
movq $0x0, 0x8(%rax)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/anuwu[P]ERPLAG-Compiler/parser.c
// Function: push
stacknode * push(stacknode * stc , tokenID token){
	if(token == TK_EPS)
		return stc;
 
	stacknode * tmp = (stacknode *) malloc(sizeof(stacknode));
	tmp->key = token;
	tmp->next = stc;
	stc = tmp;
 
	return tmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x36, %esi
je 0xb597
movl %esi, %r14d
movl $0x10, %edi
callq 0x1120
movl %r14d, (%rax)
movq %rbx, 0x8(%rax)
movq %rax, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/anuwu[P]ERPLAG-Compiler/parser.c
// Function: pop
stacknode * pop(stacknode * stc){
	if(stc==NULL){
		printf("Stack is already empty\n");
		return stc;
	}
		
	
	stacknode * tmp = stc;
	stc = stc->next;
	free(tmp);
	return stc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0xb5b5
movq 0x8(%rdi), %rbx
callq 0x1030
jmp 0xb5c3
leaq 0x6f0e(%rip), %rdi      # 0x124ca
callq 0x1070
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/anuwu[P]ERPLAG-Compiler/parser.c
// Function: pushRule
stacknode * pushRule(stacknode * stc,Rule *allRules, int rule_index){
	stc = pop(stc);	// E-> abc - popping E
 
	stacknode * tmp_stack = initStack();
	// tmp_stack->key = -2;
	
	node * tmp = allRules[rule_index].RHS; // pushing a
	tmp_stack->key = tmp->key;
	tmp = tmp->next;
 
	while(tmp!=NULL){ //pushing b then c
		tmp_stack = push(tmp_stack,tmp->key);
		tmp = tmp->next;
	} 
 
	while(tmp_stack){
		stc = push(stc,(tokenID)tmp_stack->key);
		tmp_stack = pop(tmp_stack);
	}
 
	return stc;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r15d
movq %rsi, %r12
callq 0xb59f
movq %rax, %rbx
movl $0x10, %edi
callq 0x1120
movq %rax, %r14
movl $0x70, (%rax)
movq $0x0, 0x8(%rax)
movslq %r15d, %rax
shlq $0x4, %rax
movq 0x8(%r12,%rax), %rax
movl (%rax), %ecx
movl %ecx, (%r14)
movq 0x8(%rax), %r15
testq %r15, %r15
je 0xb63e
movl (%r15), %r12d
cmpl $0x36, %r12d
je 0xb638
movl $0x10, %edi
callq 0x1120
movl %r12d, (%rax)
movq %r14, 0x8(%rax)
movq %rax, %r14
movq 0x8(%r15), %r15
jmp 0xb616
testq %r14, %r14
je 0xb674
movl (%r14), %r15d
cmpl $0x36, %r15d
je 0xb660
movl $0x10, %edi
callq 0x1120
movl %r15d, (%rax)
movq %rbx, 0x8(%rax)
movq %rax, %rbx
movq 0x8(%r14), %r15
movq %r14, %rdi
callq 0x1030
movq %r15, %r14
testq %r15, %r15
jne 0xb643
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/anuwu[P]ERPLAG-Compiler/parser.c
// Function: printSL
void printSL(stacknode * stc){
	stacknode * tmp = stc;
	while(tmp){
		printf(" %d",tmp->key);
		tmp = tmp->next;
	}
	endl;
}

// Assembly:
testq %rdi, %rdi
je 0xb6af
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x4b9c(%rip), %r14      # 0x10232
movl (%rbx), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x10b0
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
jne 0xb696
popq %rbx
popq %r14
popq %rbp
movl $0xa, %edi
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O1/anuwu[P]ERPLAG-Compiler/parser.c
// Function: addRulesParseTree
void addRulesParseTree (treeNode *parent, Rule *allRules, int rule_index)
{
	node* ptr = allRules[rule_index].RHS ;
	treeNode* child ; 
	nodeTag tag ;
	TNT tnt ;
 
	while (ptr!=NULL)
	{
		//treeNode* create_node (nodeTag tag, TNT tnt)
		if (isNonTerminal (ptr->key))
		{
			tag = NON_TERMINAL ;
			tnt.nonTerm = ptr->key ;
		}
		else if (isTerminal (ptr->key))
		{
			tag = TERMINAL ;
			tnt.term = (token *) malloc (sizeof(token)) ;
			tnt.term->id = ptr->key ;
			tnt.term->lexeme = NULL ;
			tnt.term->lineNumber = -1 ;
		}
 
		child = create_node (tag, tnt) ;
		add_child (parent, child) ;
		
		ptr = ptr->next ;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, -0x30(%rbp)
movslq %edx, %rax
shlq $0x4, %rax
movq 0x8(%rsi,%rax), %r15
testq %r15, %r15
je 0xb7a2
movq -0x30(%rbp), %rax
leaq 0x28(%rax), %rcx
movq %rcx, -0x38(%rbp)
movq 0x28(%rax), %r13
movl (%r15), %ebx
cmpq $0x35, %rbx
ja 0xb714
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
andq %rax, %r14
orq %rbx, %r14
movl $0x1, %r12d
jmp 0xb73a
cmpl $0x72, %ebx
ja 0xb73a
movl $0x18, %edi
callq 0x1120
movq %rax, %r14
movl %ebx, (%rax)
movq $0x0, 0x8(%rax)
movl $0xffffffff, 0x10(%rax) # imm = 0xFFFFFFFF
xorl %r12d, %r12d
movl $0x40, %edi
callq 0x1120
movl %r12d, (%rax)
movq %r14, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x28(%rax)
movq $0x0, 0x38(%rax)
movl $0xfffffffb, 0x20(%rax) # imm = 0xFFFFFFFB
movups %xmm0, 0x10(%rax)
movq -0x38(%rbp), %rcx
movq %rax, %rdx
testq %r13, %r13
je 0xb787
movq %r13, %rdx
movq %rdx, %rcx
movq 0x30(%rdx), %rdx
testq %rdx, %rdx
jne 0xb774
addq $0x30, %rcx
movq %r13, %rdx
movq %rax, (%rcx)
movq -0x30(%rbp), %rcx
movq %rcx, 0x38(%rax)
movq 0x8(%r15), %r15
movq %rdx, %r13
testq %r15, %r15
jne 0xb6f3
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/anuwu[P]ERPLAG-Compiler/parser.c
// Function: deletePT
void deletePT (treeNode *node)
{
	if (node == NULL)
		return ;

	treeNode *ptr ;
	ptr = node->child ;
	free (node) ;

	while (ptr != NULL)
	{
		deletePT (ptr) ;
		ptr = ptr->next ;
	}
}

// Assembly:
testq %rdi, %rdi
je 0xbcf6
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x28(%rdi), %rbx
callq 0x1030
testq %rbx, %rbx
je 0xbcf0
movq %rbx, %rdi
callq 0xbcc9
movq 0x30(%rbx), %rbx
jmp 0xbcdd
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/anuwu[P]ERPLAG-Compiler/symbolTable.c
// Function: hashFunction
int hashFunction ( char* lexeme , int size ) 
{
	if (lexeme == NULL)
		return 0 ;

	int sm = 0 ;
	int i = 0 ;

	while( lexeme[i] != '\0'){
		sm += lexeme[i] ;
		i++ ;
	}
	return sm%size ;
}

// Assembly:
testq %rdi, %rdi
je 0xbd1d
movb (%rdi), %cl
testb %cl, %cl
je 0xbd20
pushq %rbp
movq %rsp, %rbp
incq %rdi
xorl %eax, %eax
movsbl %cl, %ecx
addl %ecx, %eax
movb (%rdi), %cl
incq %rdi
testb %cl, %cl
jne 0xbd0c
popq %rbp
jmp 0xbd22
xorl %eax, %eax
retq
xorl %eax, %eax
cltd
idivl %esi
movl %edx, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/anuwu[P]ERPLAG-Compiler/symbolTable.c
// Function: createBaseST
baseST * createBaseST () 
{
	baseST * tmp = ( baseST *) malloc ( sizeof(baseST)) ;
	tmp->driverST =  NULL ;
	tmp->semanticError = 0 ;
	
	for ( int i = 0 ; i < MODULE_BIN_COUNT ; i++ ) {
		tmp->modules[i] = NULL ;
	}
	for ( int i = 0 ; i < LOCAL_BIN_COUNT ; i++ ) {
		tmp->vars[i] = NULL ;
	}
	return tmp ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0xe0, %edi
callq 0x1120
xorps %xmm0, %xmm0
movups %xmm0, 0x68(%rax)
movups %xmm0, 0x78(%rax)
movups %xmm0, 0x88(%rax)
movups %xmm0, 0x98(%rax)
movups %xmm0, 0xa8(%rax)
movups %xmm0, 0xb8(%rax)
movups %xmm0, 0xc8(%rax)
movl $0x0, 0xd8(%rax)
movups %xmm0, (%rax)
movups %xmm0, 0x10(%rax)
movups %xmm0, 0x20(%rax)
movups %xmm0, 0x30(%rax)
movups %xmm0, 0x40(%rax)
movups %xmm0, 0x50(%rax)
movq $0x0, 0x60(%rax)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/anuwu[P]ERPLAG-Compiler/symbolTable.c
// Function: createModuleST
moduleST * createModuleST (void *parent, char * lexeme, int currOffset) 
{
	moduleST * tmp = ( moduleST *) malloc ( sizeof(moduleST)) ;

	tmp->lexeme = lexeme ;
	tmp->tableType = MODULE_ST ;

	for ( int i = 0 ; i < LOCAL_BIN_COUNT ; i++ ) {
		tmp->localVars[i] = NULL ;
		
	}

	for (int i = 0 ; i < IO_BIN_COUNT ; i++) {
		tmp->inputVars[i] = NULL ;
		tmp->outputVars[i] = NULL ;
	}

	for ( int i = 0 ; i < MODULE_BIN_COUNT ; i++ ) {
		tmp->scopeVars[i] = NULL ;
	}

	tmp->parent = parent ;
	tmp->currOffset = currOffset ;
	tmp->filledMod = 0 ;
	tmp->outputSize = 0 ;
	tmp->inputSize = 0 ;
	tmp->scopeSize = 0 ;

	return tmp ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
movl $0x118, %edi            # imm = 0x118
callq 0x1120
movq %r14, (%rax)
movl $0x1, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x28(%rax)
movups %xmm0, 0x38(%rax)
movups %xmm0, 0x48(%rax)
movups %xmm0, 0x58(%rax)
movups %xmm0, 0x68(%rax)
xorl %ecx, %ecx
movq %rcx, 0x78(%rax)
movups %xmm0, 0x88(%rax)
movups %xmm0, 0x98(%rax)
movups %xmm0, 0xa8(%rax)
movups %xmm0, 0xb8(%rax)
movups %xmm0, 0xc8(%rax)
movups %xmm0, 0xd8(%rax)
movups %xmm0, 0xe8(%rax)
movq %rcx, 0xf8(%rax)
movq %r15, 0x10(%rax)
movl %ebx, 0x10c(%rax)
movq %rcx, 0x100(%rax)
movl %ecx, 0x108(%rax)
movl %ecx, 0x110(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/anuwu[P]ERPLAG-Compiler/symbolTable.c
// Function: createScopeST
moduleST * createScopeST (moduleST* parent , stType scopeType) 
{
	char * lexeme = (char*) malloc(sizeof(char)*20) ;
	strcpy ( lexeme , generateString () ) ;

	moduleST * tmp = createModuleST ((void *)parent, lexeme, parent->currOffset) ;
	tmp->tableType = scopeType ;

	return tmp ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl $0x14, %edi
callq 0x1120
movq %rax, %r15
movl $0x1, %edx
leaq 0x260da(%rip), %rax     # 0x32010
movzbl -0x1(%rdx,%rax), %ecx
cmpl $0x7a, %ecx
jne 0xbf4a
movb $0x61, -0x1(%rdx,%rax)
incq %rdx
jmp 0xbf36
testl %ecx, %ecx
jne 0xbf61
leaq 0x260bb(%rip), %rdi     # 0x32010
movl $0x61, %esi
callq 0x10c0
jmp 0xbf67
incb %cl
movb %cl, -0x1(%rdx,%rax)
leaq 0x260a2(%rip), %rsi     # 0x32010
movq %r15, %rdi
callq 0x1050
movl 0x10c(%r14), %r12d
movl $0x118, %edi            # imm = 0x118
callq 0x1120
movq %r15, (%rax)
movl $0x1, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rax)
movups %xmm0, 0x28(%rax)
movups %xmm0, 0x38(%rax)
movups %xmm0, 0x48(%rax)
movups %xmm0, 0x58(%rax)
movups %xmm0, 0x68(%rax)
xorl %ecx, %ecx
movq %rcx, 0x78(%rax)
movups %xmm0, 0x88(%rax)
movups %xmm0, 0x98(%rax)
movups %xmm0, 0xa8(%rax)
movups %xmm0, 0xb8(%rax)
movups %xmm0, 0xc8(%rax)
movups %xmm0, 0xd8(%rax)
movups %xmm0, 0xe8(%rax)
movq %rcx, 0xf8(%rax)
movq %r14, 0x10(%rax)
movl %r12d, 0x10c(%rax)
movq %rcx, 0x100(%rax)
movl %ecx, 0x108(%rax)
movl %ecx, 0x110(%rax)
movl %ebx, 0x8(%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/anuwu[P]ERPLAG-Compiler/symbolTable.c
// Function: createVarST
varST * createVarST (char *lexeme, void *scope, variableType varType, tokenID datatype) 
{
	varST * tmp = (varST *) malloc ( sizeof(varST)) ;

	tmp->lexeme = lexeme ;
	tmp->datatype = datatype ;
	tmp->offset = 0 ; //default value
	tmp->size = 0 ;
	tmp->tinker = 0 ;
	tmp->arrayIndices = NULL ;
	tmp->scope = scope ;
	tmp->varType = varType ;

	return tmp ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebx
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
movl $0x38, %edi
callq 0x1120
movq %r12, (%rax)
movl %ebx, 0x8(%rax)
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rax)
movl $0x0, 0x20(%rax)
movq %r15, 0x28(%rax)
movl %r14d, 0x30(%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/anuwu[P]ERPLAG-Compiler/symbolTable.c
// Function: insertModuleSTInbaseST
void insertModuleSTInbaseST (moduleST * thisModule) 
{

	int index = hashFunction ( thisModule->lexeme , MODULE_BIN_COUNT ) ;

	moduleSTentry * tmp = ( moduleSTentry *) malloc ( sizeof( moduleSTentry)) ;
	tmp->thisModuleST = thisModule ;
	tmp->next = realBase->modules[index] ;
	realBase->modules[index] = tmp ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0xc0aa
movb (%rax), %cl
xorl %r14d, %r14d
testb %cl, %cl
je 0xc0ad
incq %rax
movsbl %cl, %ecx
addl %ecx, %r14d
movb (%rax), %cl
incq %rax
testb %cl, %cl
jne 0xc077
movslq %r14d, %rax
imulq $0x4ec4ec4f, %rax, %rcx # imm = 0x4EC4EC4F
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x22, %rcx
addl %edx, %ecx
leal (%rcx,%rcx,2), %edx
leal (%rcx,%rdx,4), %ecx
subl %ecx, %eax
movslq %eax, %r14
jmp 0xc0ad
xorl %r14d, %r14d
movl $0x10, %edi
callq 0x1120
movq %rbx, (%rax)
movq 0x25f67(%rip), %rcx     # 0x32028
movq 0x68(%rcx,%r14,8), %rdx
movq %rdx, 0x8(%rax)
movq %rax, 0x68(%rcx,%r14,8)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/anuwu[P]ERPLAG-Compiler/symbolTable.c
// Function: insertVarSTInbaseST
void insertVarSTInbaseST (varST * thisVarST) 
{
	int index = hashFunction ( thisVarST->lexeme , LOCAL_BIN_COUNT ) ;

	varSTentry * tmp = ( varSTentry *) malloc (sizeof(varSTentry)) ;
	tmp->thisVarST = thisVarST ;
	tmp->next = realBase->vars[index] ;
	realBase->vars[index] = tmp ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0xc125
movb (%rax), %cl
xorl %r14d, %r14d
testb %cl, %cl
je 0xc128
incq %rax
movsbl %cl, %ecx
addl %ecx, %r14d
movb (%rax), %cl
incq %rax
testb %cl, %cl
jne 0xc0f2
movslq %r14d, %rax
imulq $0x4ec4ec4f, %rax, %rcx # imm = 0x4EC4EC4F
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x22, %rcx
addl %edx, %ecx
leal (%rcx,%rcx,2), %edx
leal (%rcx,%rdx,4), %ecx
subl %ecx, %eax
movslq %eax, %r14
jmp 0xc128
xorl %r14d, %r14d
movl $0x10, %edi
callq 0x1120
movq %rbx, (%rax)
movq 0x25eec(%rip), %rcx     # 0x32028
movq (%rcx,%r14,8), %rdx
movq %rdx, 0x8(%rax)
movq %rax, (%rcx,%r14,8)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/anuwu[P]ERPLAG-Compiler/symbolTable.c
// Function: insertScopeST
void insertScopeST ( moduleST* parent , moduleST * thisScopeST ) 
{
	int index = hashFunction ( thisScopeST->lexeme , MODULE_BIN_COUNT ) ;

	moduleSTentry * tmp = ( moduleSTentry * ) malloc ( sizeof ( moduleSTentry )) ;

	tmp->thisModuleST = thisScopeST ;
	tmp->next = (parent->scopeVars)[index] ;
	(parent->scopeVars)[index] = tmp ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rsi), %rax
testq %rax, %rax
je 0xc1a4
movb (%rax), %cl
xorl %r15d, %r15d
testb %cl, %cl
je 0xc1a7
incq %rax
movsbl %cl, %ecx
addl %ecx, %r15d
movb (%rax), %cl
incq %rax
testb %cl, %cl
jne 0xc171
movslq %r15d, %rax
imulq $0x4ec4ec4f, %rax, %rcx # imm = 0x4EC4EC4F
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x22, %rcx
addl %edx, %ecx
leal (%rcx,%rcx,2), %edx
leal (%rcx,%rdx,4), %ecx
subl %ecx, %eax
movslq %eax, %r15
jmp 0xc1a7
xorl %r15d, %r15d
movl $0x10, %edi
callq 0x1120
movq %r14, (%rax)
movq 0x98(%rbx,%r15,8), %rcx
movq %rcx, 0x8(%rax)
movq %rax, 0x98(%rbx,%r15,8)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/anuwu[P]ERPLAG-Compiler/symbolTable.c
// Function: insertVar
void insertVar (moduleST *thisModule, varST *thisVarST, insertVarType flag)
{
	int index, binCount ;
	varSTentry **list ;

	switch (flag)
	{
		case INSERT_INPUT : 
			list = thisModule->inputVars ;
			binCount = IO_BIN_COUNT ;
			break ;

		case INSERT_OUTPUT :
			list = thisModule->outputVars ;
			binCount = IO_BIN_COUNT ;
			break ;

		case INSERT_DYNAMIC :
			list = thisModule->dynamicVars ;
			binCount = DYNAMIC_BIN_COUNT ;
			break ;

		case INSERT_LOCAL :
			list = thisModule->localVars ;
			binCount = LOCAL_BIN_COUNT ;
			break ;
	}

	index = hashFunction (thisVarST->lexeme , binCount) ;

	varSTentry * tmp = ( varSTentry * ) malloc ( sizeof(varSTentry)) ;
	tmp->thisVarST = thisVarST ;
	tmp->next = list[index] ; 
	list[index] = tmp ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movslq %edx, %rdx
leaq 0x7e5b(%rip), %rax      # 0x14048
movq (%rax,%rdx,8), %rcx
movq (%rsi), %rax
xorl %r15d, %r15d
testq %rax, %rax
je 0xc22a
leaq 0x64bd(%rip), %rsi      # 0x126c0
movl (%rsi,%rdx,4), %esi
movb (%rax), %dl
testb %dl, %dl
je 0xc221
incq %rax
xorl %r15d, %r15d
movsbl %dl, %edx
addl %edx, %r15d
movb (%rax), %dl
incq %rax
testb %dl, %dl
jne 0xc212
movl %r15d, %eax
cltd
idivl %esi
movslq %edx, %r15
addq %rcx, %rbx
movl $0x10, %edi
callq 0x1120
movq %r14, (%rax)
movq (%rbx,%r15,8), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%rbx,%r15,8)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/anuwu[P]ERPLAG-Compiler/symbolTable.c
// Function: searchVarInbaseST
varST * searchVarInbaseST (char * lexeme ) 
{
	int index = hashFunction ( lexeme , LOCAL_BIN_COUNT ) ;

	varSTentry * tmp = realBase->vars[index] ;
	while ( tmp!= NULL ){
		if( strcmp(tmp->thisVarST->lexeme , lexeme) == 0 )
			return tmp->thisVarST ;
		
		tmp = tmp->next ;
	}
	return NULL ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
je 0xc29f
movb (%rbx), %cl
xorl %eax, %eax
testb %cl, %cl
je 0xc2a1
leaq 0x1(%rbx), %rdx
movsbl %cl, %ecx
addl %ecx, %eax
movb (%rdx), %cl
incq %rdx
testb %cl, %cl
jne 0xc26f
cltq
imulq $0x4ec4ec4f, %rax, %rcx # imm = 0x4EC4EC4F
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x22, %rcx
addl %edx, %ecx
leal (%rcx,%rcx,2), %edx
leal (%rcx,%rdx,4), %ecx
subl %ecx, %eax
cltq
jmp 0xc2a1
xorl %eax, %eax
movq 0x25d80(%rip), %rcx     # 0x32028
movq (%rcx,%rax,8), %r15
testq %r15, %r15
je 0xc2c9
movq (%r15), %r14
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x10f0
testl %eax, %eax
je 0xc2cc
movq 0x8(%r15), %r15
jmp 0xc2ac
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/anuwu[P]ERPLAG-Compiler/symbolTable.c
// Function: searchModuleInbaseST
moduleST * searchModuleInbaseST (char * lexeme) 
{
	int index = hashFunction ( lexeme , MODULE_BIN_COUNT ) ;

	moduleSTentry * tmp = realBase->modules[index] ;
	while ( tmp!= NULL ) {
		if ((tmp->thisModuleST->tableType == MODULE_ST /*||  tmp->thisModuleST->tableType == MODULE_REDEC_ST*/)&& strcmp ( tmp->thisModuleST->lexeme , lexeme) == 0 )
			return tmp->thisModuleST ;

		tmp = tmp->next ;
	}
	return NULL ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
testq %rdi, %rdi
je 0xc328
movb (%rbx), %cl
xorl %eax, %eax
testb %cl, %cl
je 0xc32a
leaq 0x1(%rbx), %rdx
movsbl %cl, %ecx
addl %ecx, %eax
movb (%rdx), %cl
incq %rdx
testb %cl, %cl
jne 0xc2f8
cltq
imulq $0x4ec4ec4f, %rax, %rcx # imm = 0x4EC4EC4F
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x22, %rcx
addl %edx, %ecx
leal (%rcx,%rcx,2), %edx
leal (%rcx,%rdx,4), %ecx
subl %ecx, %eax
cltq
jmp 0xc32a
xorl %eax, %eax
movq 0x25cf7(%rip), %rcx     # 0x32028
movq 0x68(%rcx,%rax,8), %r15
testq %r15, %r15
je 0xc35a
movq (%r15), %r14
cmpl $0x1, 0x8(%r14)
jne 0xc354
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x10f0
testl %eax, %eax
je 0xc35d
movq 0x8(%r15), %r15
jmp 0xc336
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/anuwu[P]ERPLAG-Compiler/symbolTable.c
// Function: searchVarModuleList
varST* searchVarModuleList (moduleST* thisModule, char *lexeme, searchVarType flag)
{
	int index, binCount ;
	varSTentry **list ;

	switch (flag)
	{
		case SEARCH_INPUT : 
			list = thisModule->inputVars ;
			binCount = IO_BIN_COUNT ;
			break ;

		case SEARCH_OUTPUT :
			list = thisModule->outputVars ;
			binCount = IO_BIN_COUNT ;
			break ;

		case INSERT_LOCAL :
			list = thisModule->localVars ;
			binCount = LOCAL_BIN_COUNT ;
			break ;
	}

	index = hashFunction (lexeme , binCount) ;

	varSTentry * tmp = list[index] ;
	while (tmp != NULL)
	{
		if(strcmp(tmp->thisVarST->lexeme , lexeme) == 0)
			return tmp->thisVarST ;
		
		tmp = tmp->next ;
	}

	return NULL ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movslq %edx, %rcx
leaq 0x636e(%rip), %rax      # 0x126f0
addq (%rax,%rcx,8), %rdi
xorl %eax, %eax
testq %rsi, %rsi
je 0xc3b7
leaq 0x6374(%rip), %rdx      # 0x12708
movl (%rdx,%rcx,4), %ecx
movb (%rbx), %dl
testb %dl, %dl
je 0xc3b1
leaq 0x1(%rbx), %rsi
xorl %eax, %eax
movsbl %dl, %edx
addl %edx, %eax
movb (%rsi), %dl
incq %rsi
testb %dl, %dl
jne 0xc3a3
cltd
idivl %ecx
movslq %edx, %rax
movq (%rdi,%rax,8), %r15
testq %r15, %r15
je 0xc3d8
movq (%r15), %r14
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x10f0
testl %eax, %eax
je 0xc3db
movq 0x8(%r15), %r15
jmp 0xc3bb
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/anuwu[P]ERPLAG-Compiler/symbolTable.c
// Function: searchVar
varST * searchVar (moduleST * thisModule , char * lexeme ) 
{	
	if (thisModule->parent == realBase)
		return searchVarModule (thisModule , lexeme) ;
	else
	{
		varST *tmp = searchVarModuleList (thisModule, lexeme, SEARCH_LOCAL) ;
		if (tmp == NULL)
			return searchVar (thisModule->parent, lexeme) ;
		else
			return tmp ;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq 0x10(%rdi), %r14
cmpq 0x25be3(%rip), %r14     # 0x32028
je 0xc461
movq %rbx, %rsi
movl $0x2, %edx
callq 0xc36b
movq %r14, %rdi
testq %rax, %rax
je 0xc43a
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0xc3e9
// File: /workspace/github_c_makefile_star2_O1/anuwu[P]ERPLAG-Compiler/symbolTable.c
// Function: printBaseST
void printBaseST () 
{
	
	printf ("************ printBaseST **************\n") ;

	if(realBase == NULL)
		return ;

	printf ("DriverST : %s\n" , realBase->driverST ? realBase->driverST->lexeme : "NULL" ) ;

	printf ("\nModules of baseST:\n") ;
	for ( int i=0 ; i<MODULE_BIN_COUNT ; i++ ) {
		moduleSTentry * tt = realBase->modules[i] ;
		while( tt ){
			printf ("\t%s" , tt->thisModuleST->lexeme ) ;
			tt = tt->next ;
		}
	}

	printf ("\nVariables of baseST:\n") ;
	for ( int i=0 ; i<LOCAL_BIN_COUNT ; i++ ) {
		varSTentry * tt = realBase->vars[i] ;
		while( tt ){
			printf ("\t%s" , tt->thisVarST->lexeme ) ;
			tt = tt->next ;
		}
	}


	printf ("\n**************************************\n") ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0x7aea(%rip), %rdi      # 0x13f89
callq 0x1070
movq 0x25b7d(%rip), %rax     # 0x32028
testq %rax, %rax
je 0xc4c1
movq 0xd0(%rax), %rax
testq %rax, %rax
je 0xc4cc
movq (%rax), %rsi
jmp 0xc4d3
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x571f(%rip), %rsi      # 0x11bf2
leaq 0x625f(%rip), %rdi      # 0x12739
xorl %eax, %eax
callq 0x10b0
leaq 0x7ac9(%rip), %rdi      # 0x13fb1
callq 0x1070
leaq 0x6254(%rip), %rbx      # 0x12748
xorl %r14d, %r14d
movq 0x25b2a(%rip), %rax     # 0x32028
movq 0x68(%rax,%r14,8), %r15
testq %r15, %r15
je 0xc51e
movq (%r15), %rax
movq (%rax), %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x10b0
movq 0x8(%r15), %r15
jmp 0xc503
incq %r14
cmpq $0xd, %r14
jne 0xc4f7
leaq 0x7a97(%rip), %rdi      # 0x13fc5
callq 0x1070
leaq 0x620e(%rip), %rbx      # 0x12748
xorl %r14d, %r14d
movq 0x25ae4(%rip), %rax     # 0x32028
movq (%rax,%r14,8), %r15
testq %r15, %r15
je 0xc563
movq (%r15), %rax
movq (%rax), %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x10b0
movq 0x8(%r15), %r15
jmp 0xc548
incq %r14
cmpq $0xd, %r14
jne 0xc53d
leaq 0x7aac(%rip), %rdi      # 0x1401f
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1070
// File: /workspace/github_c_makefile_star2_O1/anuwu[P]ERPLAG-Compiler/symbolTable.c
// Function: idListTinker
void idListTinker (moduleST* baseModule, astNode *idListHead)
{
	varST *searchedVar ;
	while (idListHead)
	{
		searchedVar = searchVar (baseModule, idListHead->tok->lexeme) ;
		if (searchedVar != NULL)
			tinkerVar (baseModule, searchedVar, idListHead) ;

		idListHead = idListHead->next ;
	}
}

// Assembly:
testq %rsi, %rsi
je 0xd4e5
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rsi
movq %r14, %rdi
callq 0xc430
testq %rax, %rax
je 0xd4d8
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0xd430
movq 0x38(%rbx), %rbx
testq %rbx, %rbx
jne 0xd4b5
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/anuwu[P]ERPLAG-Compiler/symbolTable.c
// Function: printOutputsNotTinkered
void printOutputsNotTinkered (moduleST *baseModule)
{
	for (int i = 0 ; i<IO_BIN_COUNT ; i++ )
	{
		varSTentry * vv = baseModule->outputVars[i] ;
		while (vv != NULL)		
		{	if (!vv->thisVarST->tinker)
			{
				#ifdef _WIN64
					printf ("%s", vv->thisVarST->lexeme) ;
				#endif
				#if defined __linux__ || defined __MACH__
					printf (ANSI_BOLD ANSI_RED "%s" ANSI_RESET, vv->thisVarST->lexeme) ;
				#endif
					
		 		if (vv->next != NULL && !vv->next->thisVarST->tinker)
					printf (", ") ;
			}
			vv = vv->next ;
		}
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq 0x90(%rdi), %r15
testq %r15, %r15
je 0xd576
leaq 0x602a(%rip), %rbx      # 0x1355a
leaq 0x4e65(%rip), %r14      # 0x1239c
movq (%r15), %rax
cmpl $0x0, 0x20(%rax)
je 0xd54b
movq 0x8(%r15), %r15
testq %r15, %r15
jne 0xd537
jmp 0xd576
movq (%rax), %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x10b0
movq 0x8(%r15), %rax
testq %rax, %rax
je 0xd540
movq (%rax), %rax
cmpl $0x0, 0x20(%rax)
jne 0xd540
movq %r14, %rdi
xorl %eax, %eax
callq 0x10b0
jmp 0xd540
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/anuwu[P]ERPLAG-Compiler/symbolTable.c
// Function: addTinkerList
void addTinkerList (guardTinkerNode *tinkerHead, int tinker)
{
	if (tinkerHead->tinker == -1)
		tinkerHead->tinker = tinker ;
	else
	{
		while (tinkerHead->next != NULL)
			tinkerHead = tinkerHead->next ;

		guardTinkerNode *tinkerNode = (guardTinkerNode *) malloc (sizeof(guardTinkerNode)) ;
		tinkerNode->tinker = tinker ;
		tinkerNode->next = NULL ;

		tinkerHead->next = tinkerNode ;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
cmpl $-0x1, (%rdi)
je 0xd5b5
movq %rdi, %r14
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
jne 0xd58f
movl $0x10, %edi
callq 0x1120
movl %ebx, (%rax)
movq $0x0, 0x8(%rax)
movq %rax, 0x8(%r14)
jmp 0xd5b7
movl %ebx, (%rdi)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/anuwu[P]ERPLAG-Compiler/symbolTable.c
// Function: getExprVars
void getExprVars (moduleST *baseModule, guardTinkerNode *tinkerHead, astNode *exprNode)
{
	if (exprNode == NULL)
		return ;

	if (exprNode->child == NULL || exprNode->child->next == NULL)	// array[index]
	{
		varST *searchedVar, *searchedVarIndex ;

		searchedVar = searchVar (baseModule, exprNode->tok->lexeme) ;
		if (searchedVar != NULL)
			addTinkerList (tinkerHead, searchedVar->tinker) ;

		if (exprNode->child != NULL && exprNode->child->id == TK_ID)
		{
			searchedVarIndex = searchVar (baseModule, exprNode->child->tok->lexeme) ;
			if (searchedVarIndex != NULL)
				addTinkerList (tinkerHead, searchedVarIndex->tinker) ;
		}
	}
	else
	{
		getExprVars (baseModule, tinkerHead, exprNode->child) ;
		if (exprNode->child != NULL)
			getExprVars (baseModule, tinkerHead, exprNode->child->next) ;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r14
testq %r12, %r12
je 0xd6ae
movq 0x30(%r12), %r15
testq %r15, %r15
je 0xd60f
cmpq $0x0, 0x38(%r15)
je 0xd60f
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0xd5bc
movq 0x30(%r12), %rax
testq %rax, %rax
je 0xd6ae
movq 0x38(%rax), %r12
jmp 0xd5d3
movq 0x8(%r12), %rax
movq 0x8(%rax), %rsi
movq %r14, %rdi
callq 0xc430
testq %rax, %rax
je 0xd65b
movl 0x20(%rax), %r12d
cmpl $-0x1, (%rbx)
je 0xd658
movq %rbx, %rax
movq %rax, %r13
movq 0x8(%rax), %rax
testq %rax, %rax
jne 0xd631
movl $0x10, %edi
callq 0x1120
movl %r12d, (%rax)
movq $0x0, 0x8(%rax)
movq %rax, 0x8(%r13)
jmp 0xd65b
movl %r12d, (%rbx)
testq %r15, %r15
je 0xd6ae
cmpl $0x40, (%r15)
jne 0xd6ae
movq 0x8(%r15), %rax
movq 0x8(%rax), %rsi
movq %r14, %rdi
callq 0xc430
testq %rax, %rax
je 0xd6ae
movl 0x20(%rax), %r14d
cmpl $-0x1, (%rbx)
je 0xd6ab
movq %rbx, %r15
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
jne 0xd684
movl $0x10, %edi
callq 0x1120
movl %r14d, (%rax)
movq $0x0, 0x8(%rax)
movq %rax, 0x8(%r15)
jmp 0xd6ae
movl %r14d, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/anuwu[P]ERPLAG-Compiler/symbolTable.c
// Function: getGuardTinkerList
guardTinkerNode* getGuardTinkerList (moduleST *baseModule, astNode *exprNode)
{
	guardTinkerNode *tinkerHead = (guardTinkerNode *) malloc (sizeof(guardTinkerNode)) ;
	tinkerHead->tinker = -1 ;
	tinkerHead->next = NULL ;

	getExprVars (baseModule, tinkerHead, exprNode) ;
	return tinkerHead ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl $0x10, %edi
callq 0x1120
movq %rax, %r15
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movq $0x0, 0x8(%rax)
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0xd5bc
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/anuwu[P]ERPLAG-Compiler/symbolTable.c
// Function: hasTinkerListChanged
int hasTinkerListChanged (guardTinkerNode *tinkerHeadBefore, guardTinkerNode *tinkerHeadAfter)
{
	while (tinkerHeadBefore && tinkerHeadAfter)
	{
		if (tinkerHeadAfter->tinker > tinkerHeadBefore->tinker)
			return 1 ;

		tinkerHeadAfter = tinkerHeadAfter->next ;
		tinkerHeadBefore = tinkerHeadBefore->next ;
	}

	return 0 ;
}

// Assembly:
testq %rdi, %rdi
sete %cl
testq %rsi, %rsi
sete %dl
xorl %eax, %eax
orb %cl, %dl
jne 0xd73a
pushq %rbp
movq %rsp, %rbp
movl (%rsi), %ecx
cmpl (%rdi), %ecx
jg 0xd734
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0xd739
movq 0x8(%rsi), %rsi
testq %rsi, %rsi
jne 0xd71a
jmp 0xd739
movl $0x1, %eax
popq %rbp
retq