LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x25fc9(%rip), %rcx     # 0x30390
movq (%rcx,%rax,8), %r14
testq %r14, %r14
je 0xa3fb
leaq 0x7197(%rip), %rbx      # 0x1156e
movl (%r14), %esi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x10b0
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0xa3d7
movl $0xa, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x1040
leaq 0x726e(%rip), %rdi      # 0x11670
popq %rbx
popq %r14
popq %rbp
jmp 0x1070
// File: /workspace/github_c_makefile_star2_O3/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:
movl 0x252ef(%rip), %eax     # 0x2f700
testl %eax, %eax
jle 0xa52b
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebx
xorl %r15d, %r15d
leaq 0x252dd(%rip), %rdx     # 0x2f710
movq %r15, %rcx
shlq $0x4, %rcx
movq 0x8(%rcx,%rdx), %r13
testq %r13, %r13
je 0xa50e
movl (%rcx,%rdx), %r14d
cmpl %ebx, (%r13)
jne 0xa4f4
movq 0x8(%r13), %r12
testq %r12, %r12
je 0xa4cf
movl (%r12), %esi
leaq 0x26566(%rip), %rax     # 0x309d0
movq (%rax,%rsi,8), %rax
testq %rax, %rax
je 0xa4c6
cmpl $0x36, (%rax)
je 0xa47e
movq 0x8(%rax), %rax
jmp 0xa46e
movl (%r12), %esi
leaq 0x26547(%rip), %rax     # 0x309d0
movq (%rax,%rsi,8), %rax
testq %rax, %rax
je 0xa4c6
cmpl $0x36, (%rax)
je 0xa49d
movq 0x8(%rax), %rax
jmp 0xa48d
movl %ebx, %edi
callq 0xa5cc
movq 0x8(%r12), %r12
testq %r12, %r12
jne 0xa47e
leaq 0x25edb(%rip), %rax     # 0x30390
cmpq $0x0, (%rax,%r14,8)
jne 0xa4ea
movl %r14d, %edi
callq 0xa40b
jmp 0xa4ea
movl %ebx, %edi
callq 0xa5cc
jmp 0xa4f4
leaq 0x25eba(%rip), %rax     # 0x30390
cmpq $0x0, (%rax,%r14,8)
jne 0xa4e5
movl %r14d, %edi
callq 0xa40b
cmpl %ebx, %r14d
je 0xa4f4
movl %ebx, %edi
movl %r14d, %esi
callq 0xa52c
movq 0x8(%r13), %r13
testq %r13, %r13
jne 0xa44c
movl 0x251f9(%rip), %eax     # 0x2f700
leaq 0x25202(%rip), %rdx     # 0x2f710
incq %r15
movslq %eax, %rcx
cmpq %rcx, %r15
jl 0xa433
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x25e4d(%rip), %r15     # 0x30390
movq (%r15,%rax,8), %r14
testq %r14, %r14
je 0xa5bd
movl %edi, %ebx
movl %edi, %r12d
cmpq $0x0, (%r15,%r12,8)
je 0xa56d
movl (%r14), %esi
movl %ebx, %edi
callq 0xa1ed
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0xa558
jmp 0xa5bd
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 0xa5bd
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 0xa595
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x263ed(%rip), %rcx     # 0x309d0
movq (%rcx,%rax,8), %r14
testq %r14, %r14
je 0xa673
movl %edi, %ebx
movl %edi, %r15d
leaq 0x25d94(%rip), %r12     # 0x30390
cmpq $0x0, (%r12,%r15,8)
je 0xa61d
movl (%r14), %esi
cmpl $0x36, %esi
je 0xa612
movl %ebx, %edi
callq 0xa1ed
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0xa603
jmp 0xa673
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 0xa673
movq %rax, %rbx
movl (%r14), %r15d
cmpl $0x36, %r15d
je 0xa66a
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 0xa645
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xaa0f
movq %rcx, %rax
movq 0x30(%rcx), %rcx
testq %rcx, %rcx
jne 0xa9fd
addq $0x30, %rax
jmp 0xaa13
leaq 0x28(%rdi), %rax
movq %rsi, (%rax)
movq %rdi, 0x38(%rsi)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xaa4a
testl %eax, %eax
jne 0xaa61
movq 0x8(%rdi), %rax
movl (%rax), %edx
movq 0x8(%rax), %rcx
movl 0x10(%rax), %r8d
leaq 0x6b9b(%rip), %rdi      # 0x115db
xorl %esi, %esi
xorl %eax, %eax
popq %rbp
jmp 0x10b0
movl 0x8(%rdi), %edx
leaq 0x6b93(%rip), %rdi      # 0x115e7
movl $0x1, %esi
xorl %eax, %eax
popq %rbp
jmp 0x10b0
leaq 0x6c19(%rip), %rdi      # 0x11681
popq %rbp
jmp 0x1070
// File: /workspace/github_c_makefile_star2_O3/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 0x6c10(%rip), %rdi      # 0x1168e
callq 0x1070
testq %rbx, %rbx
je 0xaaa0
movq %rbx, %rdi
callq 0xaa1c
movl $0xa, %edi
callq 0x1040
movq 0x30(%rbx), %rbx
jmp 0xaa83
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xab09
movq 0x8(%rdi), %rbx
callq 0x1030
jmp 0xab17
leaq 0x6b8e(%rip), %rdi      # 0x1169e
callq 0x1070
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xaaf3
movq %rax, %rbx
movl $0x10, %edi
callq 0x1120
movq %rax, %r14
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 0xab94
movl (%r15), %r12d
cmpl $0x36, %r12d
je 0xab86
movl $0x10, %edi
callq 0x1120
movl %r12d, (%rax)
movq %r14, 0x8(%rax)
movq %rax, %r14
movq 0x8(%r15), %r15
testq %r15, %r15
jne 0xab69
testq %r14, %r14
je 0xabc5
movl (%r14), %r15d
cmpl $0x36, %r15d
je 0xabb1
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 0xab94
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xac00
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x464b(%rip), %r14      # 0xf232
movl (%rbx), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x10b0
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
jne 0xabe7
popq %rbx
popq %r14
popq %rbp
movl $0xa, %edi
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O3/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
pushq %rax
movq %rdi, -0x30(%rbp)
movslq %edx, %rax
shlq $0x4, %rax
movq 0x8(%rsi,%rax), %r15
testq %r15, %r15
je 0xacdf
movq -0x30(%rbp), %rax
leaq 0x28(%rax), %r12
movl (%r15), %ebx
cmpq $0x35, %rbx
ja 0xac5a
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
andq %rax, %r14
orq %rbx, %r14
movl $0x1, %r13d
jmp 0xac80
cmpl $0x72, %ebx
ja 0xac80
movl $0x18, %edi
callq 0x1120
movq %rax, %r14
movl %ebx, (%rax)
movq $0x0, 0x8(%rax)
movl $0xffffffff, 0x10(%rax) # imm = 0xFFFFFFFF
xorl %r13d, %r13d
movl $0x40, %edi
callq 0x1120
movl %r13d, (%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 (%r12), %rdx
movq %r12, %rcx
testq %rdx, %rdx
je 0xacc7
movq %rdx, %rcx
movq 0x30(%rdx), %rdx
testq %rdx, %rdx
jne 0xacb7
addq $0x30, %rcx
movq %rax, (%rcx)
movq -0x30(%rbp), %rcx
movq %rcx, 0x38(%rax)
movq 0x8(%r15), %r15
testq %r15, %r15
jne 0xac39
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xb1fe
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x28(%rdi), %rbx
callq 0x1030
testq %rbx, %rbx
je 0xb1f8
movq %rbx, %rdi
callq 0xb1d1
movq 0x30(%rbx), %rbx
jmp 0xb1e5
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 0xb225
movb (%rdi), %cl
testb %cl, %cl
je 0xb228
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 0xb214
popq %rbp
jmp 0xb22a
xorl %eax, %eax
retq
xorl %eax, %eax
cltd
idivl %esi
movl %edx, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x25c1b(%rip), %rax     # 0x31010
movzbl -0x1(%rdx,%rax), %ecx
cmpl $0x7a, %ecx
jne 0xb409
movb $0x61, -0x1(%rdx,%rax)
incq %rdx
jmp 0xb3f5
testl %ecx, %ecx
jne 0xb420
leaq 0x25bfc(%rip), %rdi     # 0x31010
movl $0x61, %esi
callq 0x10c0
jmp 0xb426
incb %cl
movb %cl, -0x1(%rdx,%rax)
leaq 0x25be3(%rip), %rsi     # 0x31010
movq %r15, %rdi
callq 0x1050
movl 0x10c(%r14), %r12d
movl $0x118, %edi            # imm = 0x118
callq 0x1120
movq %r15, (%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_O3/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 0xb562
movb (%rax), %cl
xorl %r14d, %r14d
testb %cl, %cl
je 0xb565
incq %rax
movsbl %cl, %ecx
addl %ecx, %r14d
movb (%rax), %cl
incq %rax
testb %cl, %cl
jne 0xb52f
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 0xb565
xorl %r14d, %r14d
movl $0x10, %edi
callq 0x1120
movq %rbx, (%rax)
movq 0x25aaf(%rip), %rcx     # 0x31028
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_O3/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 0xb5dd
movb (%rax), %cl
xorl %r14d, %r14d
testb %cl, %cl
je 0xb5e0
incq %rax
movsbl %cl, %ecx
addl %ecx, %r14d
movb (%rax), %cl
incq %rax
testb %cl, %cl
jne 0xb5aa
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 0xb5e0
xorl %r14d, %r14d
movl $0x10, %edi
callq 0x1120
movq %rbx, (%rax)
movq 0x25a34(%rip), %rcx     # 0x31028
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_O3/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 0xb65c
movb (%rax), %cl
xorl %r15d, %r15d
testb %cl, %cl
je 0xb65f
incq %rax
movsbl %cl, %ecx
addl %ecx, %r15d
movb (%rax), %cl
incq %rax
testb %cl, %cl
jne 0xb629
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 0xb65f
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_O3/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 0x79b3(%rip), %rax      # 0x13058
movq (%rax,%rdx,8), %rcx
movq (%rsi), %rax
xorl %r15d, %r15d
testq %rax, %rax
je 0xb6e2
leaq 0x6015(%rip), %rsi      # 0x116d0
movl (%rsi,%rdx,4), %esi
movb (%rax), %dl
testb %dl, %dl
je 0xb6d9
incq %rax
xorl %r15d, %r15d
movsbl %dl, %edx
addl %edx, %r15d
movb (%rax), %dl
incq %rax
testb %dl, %dl
jne 0xb6ca
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_O3/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 0xb757
movb (%rbx), %cl
xorl %eax, %eax
testb %cl, %cl
je 0xb759
leaq 0x1(%rbx), %rdx
movsbl %cl, %ecx
addl %ecx, %eax
movb (%rdx), %cl
incq %rdx
testb %cl, %cl
jne 0xb727
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 0xb759
xorl %eax, %eax
movq 0x258c8(%rip), %rcx     # 0x31028
movq (%rcx,%rax,8), %r15
testq %r15, %r15
je 0xb781
movq (%r15), %r14
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x10f0
testl %eax, %eax
je 0xb784
movq 0x8(%r15), %r15
jmp 0xb764
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xb7e0
movb (%rbx), %cl
xorl %eax, %eax
testb %cl, %cl
je 0xb7e2
leaq 0x1(%rbx), %rdx
movsbl %cl, %ecx
addl %ecx, %eax
movb (%rdx), %cl
incq %rdx
testb %cl, %cl
jne 0xb7b0
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 0xb7e2
xorl %eax, %eax
movq 0x2583f(%rip), %rcx     # 0x31028
movq 0x68(%rcx,%rax,8), %r15
testq %r15, %r15
je 0xb812
movq (%r15), %r14
cmpl $0x1, 0x8(%r14)
jne 0xb80c
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x10f0
testl %eax, %eax
je 0xb815
movq 0x8(%r15), %r15
jmp 0xb7ee
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x5ec6(%rip), %rax      # 0x11700
addq (%rax,%rcx,8), %rdi
xorl %eax, %eax
testq %rsi, %rsi
je 0xb86f
leaq 0x5ecc(%rip), %rdx      # 0x11718
movl (%rdx,%rcx,4), %ecx
movb (%rbx), %dl
testb %dl, %dl
je 0xb869
leaq 0x1(%rbx), %rsi
xorl %eax, %eax
movsbl %dl, %edx
addl %edx, %eax
movb (%rsi), %dl
incq %rsi
testb %dl, %dl
jne 0xb85b
cltd
idivl %ecx
movslq %edx, %rax
movq (%rdi,%rax,8), %r15
testq %r15, %r15
je 0xb890
movq (%r15), %r14
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x10f0
testl %eax, %eax
je 0xb893
movq 0x8(%r15), %r15
jmp 0xb873
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq 0x2572c(%rip), %r14     # 0x31028
movq 0x10(%rdi), %r15
cmpq %r14, %r15
je 0xb925
movq %rbx, %rsi
movl $0x2, %edx
callq 0xb823
movq %r15, %rdi
testq %rax, %rax
je 0xb8fc
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xb8a1
// File: /workspace/github_c_makefile_star2_O3/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 0x7630(%rip), %rdi      # 0x12f99
callq 0x1070
movq 0x256b3(%rip), %rax     # 0x31028
testq %rax, %rax
je 0xb98b
movq 0xd0(%rax), %rax
testq %rax, %rax
je 0xb996
movq (%rax), %rsi
jmp 0xb99d
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x5255(%rip), %rsi      # 0x10bf2
leaq 0x5da5(%rip), %rdi      # 0x11749
xorl %eax, %eax
callq 0x10b0
leaq 0x760f(%rip), %rdi      # 0x12fc1
callq 0x1070
leaq 0x5d9a(%rip), %rbx      # 0x11758
xorl %r14d, %r14d
movq 0x25660(%rip), %rax     # 0x31028
movq 0x68(%rax,%r14,8), %r15
testq %r15, %r15
je 0xb9e8
movq (%r15), %rax
movq (%rax), %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x10b0
movq 0x8(%r15), %r15
jmp 0xb9cd
incq %r14
cmpq $0xd, %r14
jne 0xb9c1
leaq 0x75dd(%rip), %rdi      # 0x12fd5
callq 0x1070
leaq 0x5d54(%rip), %rbx      # 0x11758
xorl %r14d, %r14d
movq 0x2561a(%rip), %rax     # 0x31028
movq (%rax,%r14,8), %r15
testq %r15, %r15
je 0xba2d
movq (%r15), %rax
movq (%rax), %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x10b0
movq 0x8(%r15), %r15
jmp 0xba12
incq %r14
cmpq $0xd, %r14
jne 0xba07
leaq 0x75f2(%rip), %rdi      # 0x1302f
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1070
// File: /workspace/github_c_makefile_star2_O3/anuwu[P]ERPLAG-Compiler/symbolTable.c
// Function: tinkerVar
void tinkerVar (moduleST *baseModule, varST *var, astNode *varASTNode)
{
	var->tinker++ ;
	if (var->varType == VAR_LOOP)
	{
		errSemantic () ;
		#ifdef _WIN64
			printf ("In module \"%s\" at line %d, loop variable \"%s\" cannot be modified\n", getParentModuleName (baseModule), varASTNode->tok->lineNumber, varASTNode->tok->lexeme) ;
		#endif
		#if defined __linux__ || __MACH__
			printf ("In module " ANSI_BOLD "%s" ANSI_RESET " at line " ANSI_BOLD ANSI_CYAN "%d" ANSI_RESET ", " ANSI_BOLD ANSI_BLACK "loop" ANSI_RESET " variable " ANSI_BOLD ANSI_RED "%s" ANSI_RESET " cannot be modified\n", getParentModuleName (baseModule), varASTNode->tok->lineNumber, varASTNode->tok->lexeme) ;
		#endif
		realBase->semanticError = 1 ;
	}
	else if (var->varType == VAR_PLACEHOLDER)
	{
		errSemantic () ;
		#ifdef _WIN64
			printf ("In module \"%s\" at line %d, placeholder variable \"%s\" cannot be modified\n", getParentModuleName (baseModule), varASTNode->tok->lineNumber, varASTNode->tok->lexeme) ;
		#endif
		#if defined __linux__ || __MACH__
			printf ("In module " ANSI_BOLD "%s" ANSI_RESET " at line " ANSI_BOLD ANSI_CYAN "%d" ANSI_RESET ", " ANSI_BOLD ANSI_BLACK "placeholder" ANSI_RESET " variable " ANSI_BOLD ANSI_RED "%s" ANSI_RESET " cannot be modified\n", getParentModuleName (baseModule), varASTNode->tok->lineNumber, varASTNode->tok->lexeme) ;
		#endif
		realBase->semanticError = 1 ;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
incl 0x20(%rsi)
movq %rdx, %rbx
movq %rdi, %r14
movl 0x30(%rsi), %eax
cmpl $0x1, %eax
je 0xca64
cmpl $0x4, %eax
jne 0xcaab
xorl %eax, %eax
callq 0xe989
movq 0x245d9(%rip), %rcx     # 0x31028
leaq 0x5a33(%rip), %rdi      # 0x12489
movq %r14, %rax
movq 0x10(%r14), %r14
cmpq %rcx, %r14
jne 0xca56
jmp 0xca85
xorl %eax, %eax
callq 0xe989
movq 0x245b6(%rip), %rcx     # 0x31028
leaq 0x5a7d(%rip), %rdi      # 0x124f6
movq %r14, %rax
movq 0x10(%r14), %r14
cmpq %rcx, %r14
jne 0xca79
movq (%rax), %rsi
movq 0x8(%rbx), %rax
movl 0x10(%rax), %edx
movq 0x8(%rax), %rcx
xorl %eax, %eax
callq 0x10b0
movq 0x24587(%rip), %rax     # 0x31028
movl $0x1, 0xd8(%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xcaf2
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 0xb8e8
testq %rax, %rax
je 0xcae5
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0xca24
movq 0x38(%rbx), %rbx
testq %rbx, %rbx
jne 0xcac2
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/anuwu[P]ERPLAG-Compiler/symbolTable.c
// Function: checkAllOutputsTinkered
int checkAllOutputsTinkered (moduleST *baseModule)
{
	for (int i = 0 ; i<IO_BIN_COUNT ; i++ )
	{
		varSTentry * vv = baseModule->outputVars[i] ;
		while (vv) 
		{
			if (!vv->thisVarST->tinker)
				return 0 ;
			vv = vv->next ;
		}
	}

	return 1 ;
}

// Assembly:
movq 0x90(%rdi), %rax
testq %rax, %rax
je 0xcb1f
pushq %rbp
movq %rsp, %rbp
movq (%rax), %rcx
movl 0x20(%rcx), %ecx
testl %ecx, %ecx
je 0xcb16
movq 0x8(%rax), %rax
testq %rax, %rax
jne 0xcb03
xorl %eax, %eax
testl %ecx, %ecx
setne %al
popq %rbp
retq
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xcb88
leaq 0x5a28(%rip), %rbx      # 0x1256a
leaq 0x4a27(%rip), %r14      # 0x11570
movq (%r15), %rax
cmpl $0x0, 0x20(%rax)
je 0xcb5d
movq 0x8(%r15), %r15
testq %r15, %r15
jne 0xcb49
jmp 0xcb88
movq (%rax), %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x10b0
movq 0x8(%r15), %rax
testq %rax, %rax
je 0xcb52
movq (%rax), %rax
cmpl $0x0, 0x20(%rax)
jne 0xcb52
movq %r14, %rdi
xorl %eax, %eax
callq 0x10b0
jmp 0xcb52
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xcbc7
movq %rdi, %r14
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
jne 0xcba1
movl $0x10, %edi
callq 0x1120
movl %ebx, (%rax)
movq $0x0, 0x8(%rax)
movq %rax, 0x8(%r14)
jmp 0xcbc9
movl %ebx, (%rdi)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testq %rdx, %rdx
je 0xccd6
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
movq 0x30(%r12), %r15
testq %r15, %r15
je 0xcc29
cmpq $0x0, 0x38(%r15)
je 0xcc29
movq %r14, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0xcbce
movq 0x30(%r12), %rax
testq %rax, %rax
je 0xccc8
movq 0x38(%rax), %r12
testq %r12, %r12
jne 0xcbee
jmp 0xccc8
movq 0x8(%r12), %rax
movq 0x8(%rax), %rsi
movq %r14, %rdi
callq 0xb8e8
testq %rax, %rax
je 0xcc75
movl 0x20(%rax), %r12d
cmpl $-0x1, (%rbx)
je 0xcc72
movq %rbx, %rax
movq %rax, %r13
movq 0x8(%rax), %rax
testq %rax, %rax
jne 0xcc4b
movl $0x10, %edi
callq 0x1120
movl %r12d, (%rax)
movq $0x0, 0x8(%rax)
movq %rax, 0x8(%r13)
jmp 0xcc75
movl %r12d, (%rbx)
testq %r15, %r15
je 0xccc8
cmpl $0x40, (%r15)
jne 0xccc8
movq 0x8(%r15), %rax
movq 0x8(%rax), %rsi
movq %r14, %rdi
callq 0xb8e8
testq %rax, %rax
je 0xccc8
movl 0x20(%rax), %r14d
cmpl $-0x1, (%rbx)
je 0xccc5
movq %rbx, %r15
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
jne 0xcc9e
movl $0x10, %edi
callq 0x1120
movl %r14d, (%rax)
movq $0x0, 0x8(%rax)
movq %rax, 0x8(%r15)
jmp 0xccc8
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_O3/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 0xcbce
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xcd54
pushq %rbp
movq %rsp, %rbp
movl (%rsi), %ecx
cmpl (%rdi), %ecx
jg 0xcd4e
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0xcd53
movq 0x8(%rsi), %rsi
testq %rsi, %rsi
jne 0xcd34
jmp 0xcd53
movl $0x1, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/anuwu[P]ERPLAG-Compiler/typeChecker.c
// Function: isVarStaticArr
int isVarStaticArr (varST *arrayVar)
{
	if (isLeftLimStatic(arrayVar) && isRightLimStatic(arrayVar))
		return 1 ;
	else
		return 0 ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1180
movq (%rax), %rcx
movq 0x10(%rbx), %rax
movq 0x8(%rax), %rdx
movq 0x8(%rdx), %rdx
movsbq (%rdx), %rdx
testb $0x8, 0x1(%rcx,%rdx,2)
je 0xe05a
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movsbq (%rax), %rdx
movl $0x1, %eax
testb $0x8, 0x1(%rcx,%rdx,2)
jne 0xe05c
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/anuwu[P]ERPLAG-Compiler/typeChecker.c
// Function: validVarIndex
int validVarIndex (moduleST *baseModule, astNode *varIndexASTNode)	// Returns TK_NUM for static index, 0 for invalid dynamic index, TK_ID for valid dynamic index
{
	// Assumes varIndexASTNode isn't NULL

	if (varIndexASTNode->id == TK_NUM)
		return TK_NUM ;

	varST *indexVar = searchVar (baseModule, varIndexASTNode->tok->lexeme) ;
	if (indexVar == NULL)
	{
		errSemantic () ;
		#ifdef _WIN64
			printf ("In module \"%s\" at line %d, index variable \"%s\" is undeclared\n", getParentModuleName (baseModule), varIndexASTNode->tok->lineNumber, varIndexASTNode->tok->lexeme) ;
		#endif
		#if defined __linux__ || defined __MACH__
			printf ("In module " ANSI_BOLD "%s" ANSI_RESET " at line " ANSI_BOLD ANSI_CYAN "%d" ANSI_RESET ", index variable " ANSI_BOLD ANSI_RED "%s" ANSI_RESET " is undeclared\n", getParentModuleName (baseModule), varIndexASTNode->tok->lineNumber, varIndexASTNode->tok->lexeme) ;
		#endif
		realBase->semanticError = 1 ;
		return 0 ;
	}
	else if (indexVar->datatype != TK_INTEGER)
	{
		errSemantic () ;
		#ifdef _WIN64
			printf ("In module \"%s\" at line %d, index variable \"%s\" needs to be of type integer\n", getParentModuleName (baseModule), varIndexASTNode->tok->lineNumber, varIndexASTNode->tok->lexeme) ;
		#endif
		#if defined __linux__ || defined __MACH__
			printf ("In module " ANSI_BOLD "%s" ANSI_RESET " at line " ANSI_BOLD ANSI_CYAN "%d" ANSI_RESET ", index variable " ANSI_BOLD ANSI_RED "%s" ANSI_RESET " needs to be of type integer\n", getParentModuleName (baseModule), varIndexASTNode->tok->lineNumber, varIndexASTNode->tok->lexeme) ;
		#endif
		realBase->semanticError = 1 ;
		return 0 ;
	}

	return TK_ID ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl $0x71, %r15d
cmpl $0x71, (%rsi)
je 0xe0eb
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rax
movq 0x8(%rax), %rsi
callq 0xb8e8
testq %rax, %rax
je 0xe0a6
movl $0x40, %r15d
cmpl $0x37, 0x8(%rax)
je 0xe0eb
leaq 0x5030(%rip), %r12      # 0x130d4
jmp 0xe0ad
leaq 0x4fcb(%rip), %r12      # 0x13078
xorl %r15d, %r15d
xorl %eax, %eax
callq 0xe989
movq %r14, %rdi
callq 0xc0ec
movq 0x8(%rbx), %rcx
movl 0x10(%rcx), %edx
movq 0x8(%rcx), %rcx
movq %r12, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x10b0
leaq 0x22f4a(%rip), %rax     # 0x31028
movq (%rax), %rax
movl $0x1, 0xd8(%rax)
movl %r15d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/anuwu[P]ERPLAG-Compiler/typeChecker.c
// Function: validStaticArrStaticIndex
int validStaticArrStaticIndex (moduleST *baseModule, varST *arrayVar, astNode *indASTNode)
{
	int num = atoi(indASTNode->tok->lexeme) , leftLim = atoi(arrayVar->arrayIndices->tokLeft->lexeme), rightLim = atoi(arrayVar->arrayIndices->tokRight->lexeme) ;
	if (num < leftLim || num > rightLim)
	{
		errSemantic () ;
		#ifdef _WIN64
			printf ("In module \"%s\" at line %d, specified index \"%s\" is out of bounds for static array variable \"%s\"\n", getParentModuleName (baseModule), indASTNode->tok->lineNumber, indASTNode->tok->lexeme, arrayVar->lexeme) ;
		#endif
		#if defined __linux__ || defined __MACH__
			printf ("In module " ANSI_BOLD "%s" ANSI_RESET " at line " ANSI_BOLD ANSI_CYAN "%d" ANSI_RESET ", specified index " ANSI_BOLD ANSI_CYAN "%s" ANSI_RESET " is out of bounds for " ANSI_BOLD ANSI_BLACK "static array" ANSI_RESET " variable " ANSI_BOLD ANSI_RED "%s\n" ANSI_RESET, getParentModuleName (baseModule), indASTNode->tok->lineNumber, indASTNode->tok->lexeme, arrayVar->lexeme) ;
		#endif
		realBase->semanticError = 1 ;
		return 0 ;
	}

	return 1 ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq 0x8(%rdx), %rax
movq 0x8(%rax), %rdi
callq 0x1140
movl %eax, %r13d
movq 0x10(%rbx), %r12
movq 0x8(%r12), %rax
movq 0x8(%rax), %rdi
callq 0x1140
cmpl %eax, %r13d
jl 0xe14e
movq 0x10(%r12), %rax
movq 0x8(%rax), %rdi
callq 0x1140
movl $0x1, %r12d
cmpl %eax, %r13d
jle 0xe193
xorl %r12d, %r12d
xorl %eax, %eax
callq 0xe989
movq %r15, %rdi
callq 0xc0ec
movq 0x8(%r14), %rcx
movl 0x10(%rcx), %edx
movq 0x8(%rcx), %rcx
movq (%rbx), %r8
leaq 0x4fc9(%rip), %rdi      # 0x1313e
movq %rax, %rsi
xorl %eax, %eax
callq 0x10b0
leaq 0x22ea2(%rip), %rax     # 0x31028
movq (%rax), %rax
movl $0x1, 0xd8(%rax)
movl %r12d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Tarsnap[P]libcperciva/tests/fork_func/check_order.c
// Function: sleep_print_func
static int
sleep_print_func(void * cookie)
{
	int ms = *((int *)cookie);

	/* Wait. */
	millisleep((size_t)ms);

	/* Write the "waited" messages to stderr. */
	if (fprintf(stderr, "waited %d ms\n", ms) < 0) {
		warnp("fprintf");
		goto err0;
	}

	/* Success! */
	return (0);

err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movslq (%rdi), %r14
movl $0x3e8, %ecx            # imm = 0x3E8
movq %r14, %rax
xorl %edx, %edx
divq %rcx
xorl %ebx, %ebx
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
imulq $0xf4240, %rdx, %rax    # imm = 0xF4240
movq %rax, 0x8(%rdi)
xorl %esi, %esi
callq 0x1100
movq 0x4d4e(%rip), %rax      # 0x5ff8
movq (%rax), %rdi
leaq 0x1e3d(%rip), %rsi      # 0x30f1
movl %r14d, %edx
xorl %eax, %eax
callq 0x1160
testl %eax, %eax
jns 0x12f3
callq 0x1080
cmpl $0x0, (%rax)
je 0x12e2
movq %rax, %rbx
leaq 0x1e0c(%rip), %rdi      # 0x30e2
xorl %eax, %eax
callq 0x2d00
andl $0x0, (%rbx)
jmp 0x12f0
leaq 0x1df9(%rip), %rdi      # 0x30e2
xorl %eax, %eax
callq 0x2e1f
pushq $-0x1
popq %rbx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/Tarsnap[P]libcperciva/tests/fork_func/check_exit.c
// Function: check_exit
int
check_exit(void)
{
	pid_t pid;
	int i;
	int rc;

	for (i = 0; i < 4; i++) {
		/* Fork. */
		if ((pid = fork_func(func_exit, &i)) == -1)
			goto err0;

		/* Check the result. */
		if ((rc = fork_func_wait(pid)) == -1)
			goto err0;
		if (rc != i)
			goto err0;
	}

	/* Success! */
	return (0);

err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
leaq 0xc(%rsp), %rbx
movl $0x0, (%rbx)
leaq 0x40(%rip), %r14        # 0x1de2
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movq %r14, %rdi
movq %rbx, %rsi
callq 0x22a4
cmpl $-0x1, %eax
je 0x1dd7
movl %eax, %edi
callq 0x2306
cmpl $-0x1, %eax
je 0x1dd7
cmpl 0xc(%rsp), %eax
jne 0x1dd7
leal 0x1(%rax), %ecx
movl %ecx, 0xc(%rsp)
cmpl $0x2, %eax
jle 0x1da7
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/Tarsnap[P]libcperciva/tests/fork_func/check_order.c
// Function: check_order
int
check_order(void)
{
	pid_t pids[NUM_PROCESSES];
	int i;

	/*-
	 * We want to output two different lists: the "spawning"
	 * messages, and the "waited" messages.  This allows the test
	 * to be more resistant to systems having different overheads
	 * for fork().
	 *
	 * To achieve this, the "spawning" messages go to stdout,
	 * while the "waited" messages go to stderr.
	 */

	/* Write the "spawning" messages to stdout. */
	for (i = 0; i < NUM_PROCESSES; i++) {
		if (fprintf(stdout, "spawning a process to wait %d ms\n",
		    SLEEP_SORT_MS[i]) < 0) {
			warnp("fprintf");
			goto err0;
		}
	}

	/* Flush stdout so that its buffer isn't duplicated in the forks. */
	if (fflush(stdout)) {
		warnp("fflush");
		goto err0;
	}

	/* Spawn the processes. */
	for (i = 0; i < NUM_PROCESSES; i++) {
		if ((pids[i] = fork_func(sleep_print_func,
		    &SLEEP_SORT_MS[i])) == -1)
			goto err0;
	}

	/* Wait for the processes to finish. */
	for (i = 0; i < NUM_PROCESSES; i++) {
		if (fork_func_wait(pids[i]))
			goto err0;
	}

	/* Success! */
	return (0);

err0:
	/* Failure! */
	return (-1);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0x41de(%rip), %r14      # 0x5fd8
leaq 0x433f(%rip), %r15      # 0x6140
leaq 0x12b8(%rip), %rbx      # 0x30c0
xorl %r12d, %r12d
movq (%r14), %rdi
movl (%r12,%r15), %edx
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1160
testl %eax, %eax
js 0x1e50
addq $0x4, %r12
cmpq $0x14, %r12
jne 0x1e0b
movq (%r14), %rdi
callq 0x1180
testl %eax, %eax
je 0x1e7c
callq 0x1080
cmpl $0x0, (%rax)
je 0x1ec7
movq %rax, %rbx
leaq 0x129c(%rip), %rdi      # 0x30ea
jmp 0x1e64
callq 0x1080
cmpl $0x0, (%rax)
je 0x1e73
movq %rax, %rbx
leaq 0x127e(%rip), %rdi      # 0x30e2
xorl %eax, %eax
callq 0x2d00
movl $0x0, (%rbx)
jmp 0x1ed5
leaq 0x1268(%rip), %rdi      # 0x30e2
jmp 0x1ece
xorl %r12d, %r12d
leaq -0xc16(%rip), %r14      # 0x1270
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
leaq (%r15,%r12), %rsi
movq %r14, %rdi
callq 0x22a4
movl %eax, (%rsp,%r12)
cmpl $-0x1, %eax
je 0x1eda
addq $0x4, %r12
cmpq $0x14, %r12
jne 0x1e8b
xorl %r14d, %r14d
movl (%rsp,%r14,4), %edi
callq 0x2306
testl %eax, %eax
jne 0x1eda
incq %r14
cmpq $0x5, %r14
jne 0x1ead
xorl %ebx, %ebx
jmp 0x1eda
leaq 0x121c(%rip), %rdi      # 0x30ea
xorl %eax, %eax
callq 0x2e1f
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq