LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x36, -0x4(%rbp)
jb 0xed0c
cmpl $0x72, -0x4(%rbp)
ja 0xed0c
jmp 0xeddd
movl -0x4(%rbp), %eax
movl %eax, %ecx
leaq 0xe648(%rip), %rax      # 0x1d360
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xeddd
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movslq -0x2c(%rbp), %rcx
leaq 0x269ae(%rip), %rax     # 0x356f0
shlq $0x4, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, -0x28(%rbp)
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xedb8
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0x27c3a(%rip), %rax     # 0x369b0
cmpq $0x0, (%rax,%rcx,8)
jne 0xed88
movq -0x18(%rbp), %rax
movl (%rax), %edi
callq 0xecf0
movl -0x4(%rbp), %edi
movq -0x18(%rbp), %rax
movl (%rax), %esi
callq 0xeb90
movq -0x18(%rbp), %rax
movl (%rax), %edi
callq 0xeca0
cmpl $0x0, %eax
je 0xedb4
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xedb6
jmp 0xedb8
jmp 0xed60
cmpq $0x0, -0x18(%rbp)
jne 0xedcc
movl -0x4(%rbp), %edi
movl $0x36, %esi
callq 0xea90
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xed23
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %eax
movl %eax, %ecx
leaq 0x27569(%rip), %rax     # 0x36370
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xee26
leaq 0x8849(%rip), %rdi      # 0x17666
movb $0x0, %al
callq 0x1090
jmp 0xee5f
jmp 0xee28
cmpq $0x0, -0x10(%rbp)
je 0xee51
movq -0x10(%rbp), %rax
movl (%rax), %esi
leaq 0x883c(%rip), %rdi      # 0x17678
movb $0x0, %al
callq 0x1090
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xee28
leaq 0x6fa9(%rip), %rdi      # 0x15e01
movb $0x0, %al
callq 0x1090
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, %ecx
leaq 0x27356(%rip), %rax     # 0x36370
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %eax
movl %eax, %ecx
leaq 0x27342(%rip), %rax     # 0x36370
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xf042
jmp 0xf0ed
cmpq $0x0, -0x18(%rbp)
jne 0xf0c0
movq -0x10(%rbp), %rax
movl (%rax), %edi
callq 0xdfe0
movq %rax, %rdx
movl -0x4(%rbp), %eax
movl %eax, %ecx
leaq 0x2730d(%rip), %rax     # 0x36370
movq %rdx, (%rax,%rcx,8)
movl -0x4(%rbp), %eax
movl %eax, %ecx
leaq 0x272fd(%rip), %rax     # 0x36370
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xf0be
movq -0x10(%rbp), %rax
movl (%rax), %edi
callq 0xdfe0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xf087
jmp 0xf0ed
jmp 0xf0c2
cmpq $0x0, -0x10(%rbp)
je 0xf0eb
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
movl -0x4(%rbp), %edi
movl -0x24(%rbp), %esi
callq 0xeb10
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xf0c2
jmp 0xf0ed
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, %ecx
leaq 0x27896(%rip), %rax     # 0x369b0
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %eax
movl %eax, %ecx
leaq 0x27242(%rip), %rax     # 0x36370
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xf142
jmp 0xf200
cmpq $0x0, -0x18(%rbp)
jne 0xf1cd
movq -0x10(%rbp), %rax
movl (%rax), %edi
callq 0xdfe0
movq %rax, %rdx
movl -0x4(%rbp), %eax
movl %eax, %ecx
leaq 0x27209(%rip), %rax     # 0x36370
movq %rdx, (%rax,%rcx,8)
movl -0x4(%rbp), %eax
movl %eax, %ecx
leaq 0x271f9(%rip), %rax     # 0x36370
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xf1cb
movq -0x10(%rbp), %rax
cmpl $0x36, (%rax)
je 0xf1bd
movq -0x10(%rbp), %rax
movl (%rax), %edi
callq 0xdfe0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xf18b
jmp 0xf200
jmp 0xf1cf
cmpq $0x0, -0x10(%rbp)
je 0xf1fe
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
cmpl $0x36, -0x24(%rbp)
je 0xf1f0
movl -0x4(%rbp), %edi
movl -0x24(%rbp), %esi
callq 0xeb10
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xf1cf
jmp 0xf200
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/anuwu[P]ERPLAG-Compiler/parser.c
// Function: nodeSymbol
char* nodeSymbol (treeNode* node)
{
	if (node == NULL)
		return "ROOT" ;

	if (node->tag == NON_TERMINAL)
		return utility_array[node->tnt.nonTerm] ;
	else
		return utility_array[node->tnt.term->id] ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xf22c
leaq 0x8457(%rip), %rax      # 0x1767d
movq %rax, -0x8(%rbp)
jmp 0xf270
movq -0x10(%rbp), %rax
cmpl $0x1, (%rax)
jne 0xf252
movq -0x10(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, %ecx
leaq 0xed9b(%rip), %rax      # 0x1dfe0
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
jmp 0xf270
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl (%rax), %eax
movl %eax, %ecx
leaq 0xed7b(%rip), %rax      # 0x1dfe0
imulq $0x28, %rcx, %rcx
addq %rcx, %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/anuwu[P]ERPLAG-Compiler/parser.c
// Function: create_root
treeNode* create_root ()
{
	treeNode *node = (treeNode *) malloc (sizeof(treeNode)) ;
 
	node->tag = NON_TERMINAL ;
	node->tnt.nonTerm = program ;
 
 	node->syntax_error = 0 ;
	node->child = NULL ;
	node->next = NULL ;
	node->parent = NULL ;
	
	node->gcode = -1 ;
	node->syn = NULL ;
	node->inh = NULL ;

	return node ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x40, %edi
callq 0x10e0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x1, (%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x24(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x8(%rbp), %rax
movl $0xffffffff, 0x20(%rax) # imm = 0xFFFFFFFF
movq -0x8(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rsi, -0x8(%rbp)
movl %edi, -0xc(%rbp)
movl $0x40, %edi
callq 0x10e0
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movq -0x8(%rbp), %rcx
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x18(%rbp), %rax
movl $0xfffffffb, 0x20(%rax) # imm = 0xFFFFFFFB
movq -0x18(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpq $0x0, 0x28(%rax)
jne 0xf805
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x28(%rax)
jmp 0xf836
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0xf82a
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xf811
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x30(%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x38(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, (%rax)
jne 0xf89d
movq -0x8(%rbp), %rax
movl (%rax), %esi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl (%rax), %edx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x10(%rax), %r8d
leaq 0x7e51(%rip), %rdi      # 0x176e5
movb $0x0, %al
callq 0x1090
jmp 0xf8d3
movq -0x8(%rbp), %rax
cmpl $0x1, (%rax)
jne 0xf8c3
movq -0x8(%rbp), %rax
movl (%rax), %esi
movq -0x8(%rbp), %rax
movl 0x8(%rax), %edx
leaq 0x7e37(%rip), %rdi      # 0x176f1
movb $0x0, %al
callq 0x1090
jmp 0xf8d1
leaq 0x7e2d(%rip), %rdi      # 0x176f7
movb $0x0, %al
callq 0x1090
jmp 0xf8d3
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x72bc(%rip), %rdi      # 0x16baf
movb $0x0, %al
callq 0x1090
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xf92e
movq -0x10(%rbp), %rdi
callq 0xf850
leaq 0x64e8(%rip), %rdi      # 0x15e01
movb $0x0, %al
callq 0x1090
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xf902
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movl $0x10, %edi
callq 0x10e0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x70, (%rax)
movq -0x8(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpl $0x36, -0x14(%rbp)
jne 0xf99f
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xf9d2
movl $0x10, %edi
callq 0x10e0
movq %rax, -0x20(%rbp)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x10(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xfa0b
leaq 0x7d0b(%rip), %rdi      # 0x17705
movb $0x0, %al
callq 0x1090
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xfa30
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x18(%rbp), %rdi
callq 0x1030
movq -0x10(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
callq 0xf9e0
movq %rax, -0x8(%rbp)
callq 0xf940
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movl (%rax), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xfac0
movq -0x20(%rbp), %rdi
movq -0x28(%rbp), %rax
movl (%rax), %esi
callq 0xf980
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xfa98
jmp 0xfac2
cmpq $0x0, -0x20(%rbp)
je 0xfaeb
movq -0x8(%rbp), %rdi
movq -0x20(%rbp), %rax
movl (%rax), %esi
callq 0xf980
movq %rax, -0x8(%rbp)
movq -0x20(%rbp), %rdi
callq 0xf9e0
movq %rax, -0x20(%rbp)
jmp 0xfac2
movq -0x8(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xfb3d
movq -0x10(%rbp), %rax
movl (%rax), %esi
leaq 0x5880(%rip), %rdi      # 0x153a8
movb $0x0, %al
callq 0x1090
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xfb14
leaq 0x62bd(%rip), %rdi      # 0x15e01
movb $0x0, %al
callq 0x1090
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0xfc33
movq -0x20(%rbp), %rax
cmpl $0x0, (%rax)
jb 0xfbb9
movq -0x20(%rbp), %rax
cmpl $0x35, (%rax)
ja 0xfbb9
movl $0x1, -0x2c(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x38(%rbp)
jmp 0xfc05
movq -0x20(%rbp), %rax
cmpl $0x36, (%rax)
jb 0xfc03
movq -0x20(%rbp), %rax
cmpl $0x72, (%rax)
ja 0xfc03
movl $0x0, -0x2c(%rbp)
movl $0x18, %edi
callq 0x10e0
movq %rax, -0x38(%rbp)
movq -0x20(%rbp), %rax
movl (%rax), %ecx
movq -0x38(%rbp), %rax
movl %ecx, (%rax)
movq -0x38(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x38(%rbp), %rax
movl $0xffffffff, 0x10(%rax) # imm = 0xFFFFFFFF
jmp 0xfc05
movl -0x2c(%rbp), %edi
movq -0x38(%rbp), %rsi
callq 0xf750
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rdi
movq -0x28(%rbp), %rsi
callq 0xf7e0
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0xfb8a
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/anuwu[P]ERPLAG-Compiler/parser.c
// Function: nextTreeNode
treeNode * nextTreeNode(treeNode* current_node){
 
 
	if(current_node->tag == TERMINAL)
	{
		if( current_node->next )
		{
			return current_node->next;
		}
		else 
		{
			treeNode* target = current_node->parent;
 
			while( target != NULL && target->next == NULL)
			{	
				target = target->parent;
			}
			if(target == NULL)
				return target;
 
			return target->next;	
		}
	}
	
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x0, (%rax)
jne 0xfcc5
movq -0x10(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0xfc6a
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0xfcc5
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x18(%rbp)
movb %al, -0x19(%rbp)
je 0xfc91
movq -0x18(%rbp), %rax
cmpq $0x0, 0x30(%rax)
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0xfc9a
jmp 0xfca8
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0xfc76
cmpq $0x0, -0x18(%rbp)
jne 0xfcb9
movq -0x18(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0xfcc5
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x10285
jmp 0x102b8
movq -0x8(%rbp), %rax
movq 0x28(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x1030
cmpq $0x0, -0x10(%rbp)
je 0x102b8
movq -0x10(%rbp), %rdi
callq 0x10270
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x1029a
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0x102db
movl $0x0, -0x4(%rbp)
jmp 0x10321
movl $0x0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x10317
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movsbl (%rax,%rcx), %eax
addl -0x18(%rbp), %eax
movl %eax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x102e9
movl -0x18(%rbp), %eax
cltd
idivl -0x14(%rbp)
movl %edx, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/anuwu[P]ERPLAG-Compiler/symbolTable.c
// Function: generateString
char * generateString () 
{
	int i=0 ; 

	while ( 1 ) {	
		if(current_lexeme[i] == '\0') 
		{
			while ( i >= 0 ){
				current_lexeme[i] = 'a' ;
				i-- ;
			}
			return current_lexeme ;
		}
		else if ( current_lexeme[i] == 'z' ){
			current_lexeme[i] = 'a' ;
			i++ ;
		}
		else {
			current_lexeme[i]++ ;
			return current_lexeme ;
		}
	}
	return current_lexeme ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, -0xc(%rbp)
movslq -0xc(%rbp), %rcx
leaq 0x26caa(%rip), %rax     # 0x36ff0
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
jne 0x1037e
jmp 0x10351
cmpl $0x0, -0xc(%rbp)
jl 0x10371
movslq -0xc(%rbp), %rcx
leaq 0x26c8e(%rip), %rax     # 0x36ff0
movb $0x61, (%rax,%rcx)
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x10351
leaq 0x26c78(%rip), %rax     # 0x36ff0
movq %rax, -0x8(%rbp)
jmp 0x103db
movslq -0xc(%rbp), %rcx
leaq 0x26c67(%rip), %rax     # 0x36ff0
movsbl (%rax,%rcx), %eax
cmpl $0x7a, %eax
jne 0x103ac
movslq -0xc(%rbp), %rcx
leaq 0x26c53(%rip), %rax     # 0x36ff0
movb $0x61, (%rax,%rcx)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x103d4
movslq -0xc(%rbp), %rcx
leaq 0x26c39(%rip), %rax     # 0x36ff0
movb (%rax,%rcx), %dl
addb $0x1, %dl
leaq 0x26c2c(%rip), %rax     # 0x36ff0
movb %dl, (%rax,%rcx)
leaq 0x26c22(%rip), %rax     # 0x36ff0
movq %rax, -0x8(%rbp)
jmp 0x103db
jmp 0x103d6
jmp 0x1033b
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movl $0xe0, %edi
callq 0x10e0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq $0x0, 0xd0(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0xd8(%rax)
movl $0x0, -0xc(%rbp)
cmpl $0xd, -0xc(%rbp)
jge 0x1044c
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq $0x0, 0x68(%rax,%rcx,8)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1042a
movl $0x0, -0x10(%rbp)
cmpl $0xd, -0x10(%rbp)
jge 0x10474
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movq $0x0, (%rax,%rcx,8)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x10453
movq -0x8(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x118, %edi            # imm = 0x118
callq 0x10e0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
movl $0x1, 0x8(%rax)
movl $0x0, -0x24(%rbp)
cmpl $0xd, -0x24(%rbp)
jge 0x104e0
movq -0x20(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq $0x0, 0x18(%rax,%rcx,8)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x104be
movl $0x0, -0x28(%rbp)
cmpl $0x1, -0x28(%rbp)
jge 0x10520
movq -0x20(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq $0x0, 0x88(%rax,%rcx,8)
movq -0x20(%rbp), %rax
movslq -0x28(%rbp), %rcx
movq $0x0, 0x90(%rax,%rcx,8)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x104e7
movl $0x0, -0x2c(%rbp)
cmpl $0xd, -0x2c(%rbp)
jge 0x1054c
movq -0x20(%rbp), %rax
movslq -0x2c(%rbp), %rcx
movq $0x0, 0x98(%rax,%rcx,8)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x10527
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x10c(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x100(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x108(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x104(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x110(%rax)
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x14, %edi
callq 0x10e0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x10330
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x1040
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x8(%rbp), %rax
movl 0x10c(%rax), %edx
callq 0x10480
movq %rax, -0x20(%rbp)
movl -0xc(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x20(%rbp), %rax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl %ecx, -0x18(%rbp)
movl $0x38, %edi
callq 0x10e0
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movl -0x18(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x8(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x1c(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x18(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x20(%rax)
movq -0x20(%rbp), %rax
movq $0x0, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x28(%rax)
movl -0x14(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x30(%rax)
movq -0x20(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl $0xd, %esi
callq 0x102c0
movl %eax, -0xc(%rbp)
movl $0x10, %edi
callq 0x10e0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq 0x268d8(%rip), %rax     # 0x37008
movslq -0xc(%rbp), %rcx
movq 0x68(%rax,%rcx,8), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rdx
movq 0x268bc(%rip), %rax     # 0x37008
movslq -0xc(%rbp), %rcx
movq %rdx, 0x68(%rax,%rcx,8)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rdi
movl $0xd, %esi
callq 0x102c0
movl %eax, -0xc(%rbp)
movl $0x10, %edi
callq 0x10e0
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, (%rax)
movq 0x26868(%rip), %rax     # 0x37008
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x18(%rbp), %rdx
movq 0x2684d(%rip), %rax     # 0x37008
movslq -0xc(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl $0xd, %esi
callq 0x102c0
movl %eax, -0x14(%rbp)
movl $0x10, %edi
callq 0x10e0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq 0x98(%rax,%rcx,8), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rdx
movq -0x8(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq %rdx, 0x98(%rax,%rcx,8)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl -0x14(%rbp), %eax
movq %rax, -0x38(%rbp)
subq $0x3, %rax
ja 0x108cc
movq -0x38(%rbp), %rax
leaq 0x6f35(%rip), %rcx      # 0x177a0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x8(%rbp), %rax
addq $0x88, %rax
movq %rax, -0x28(%rbp)
movl $0x1, -0x1c(%rbp)
jmp 0x108cc
movq -0x8(%rbp), %rax
addq $0x90, %rax
movq %rax, -0x28(%rbp)
movl $0x1, -0x1c(%rbp)
jmp 0x108cc
movq -0x8(%rbp), %rax
addq $0x80, %rax
movq %rax, -0x28(%rbp)
movl $0x1, -0x1c(%rbp)
jmp 0x108cc
movq -0x8(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x28(%rbp)
movl $0xd, -0x1c(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rdi
movl -0x1c(%rbp), %esi
callq 0x102c0
movl %eax, -0x18(%rbp)
movl $0x10, %edi
callq 0x10e0
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rcx
movq -0x30(%rbp), %rax
movq %rcx, (%rax)
movq -0x28(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rcx
movq -0x30(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x30(%rbp), %rdx
movq -0x28(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq %rdx, (%rax,%rcx,8)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0xd, %esi
callq 0x102c0
movl %eax, -0x14(%rbp)
movq 0x266b4(%rip), %rax     # 0x37008
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x1099a
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x10c0
cmpl $0x0, %eax
jne 0x1098c
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x109a2
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x10960
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl $0xd, %esi
callq 0x102c0
movl %eax, -0x14(%rbp)
movq 0x26634(%rip), %rax     # 0x37008
movslq -0x14(%rbp), %rcx
movq 0x68(%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x10a28
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpl $0x1, 0x8(%rax)
jne 0x10a1a
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
movq -0x10(%rbp), %rsi
callq 0x10c0
cmpl $0x0, %eax
jne 0x10a1a
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x10a30
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x109e1
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movl %edx, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
movl %eax, -0x3c(%rbp)
testl %eax, %eax
je 0x10a73
jmp 0x10a5f
movl -0x3c(%rbp), %eax
subl $0x1, %eax
je 0x10a8a
jmp 0x10a69
movl -0x3c(%rbp), %eax
subl $0x2, %eax
je 0x10aa1
jmp 0x10ab4
movq -0x10(%rbp), %rax
addq $0x88, %rax
movq %rax, -0x30(%rbp)
movl $0x1, -0x24(%rbp)
jmp 0x10ab4
movq -0x10(%rbp), %rax
addq $0x90, %rax
movq %rax, -0x30(%rbp)
movl $0x1, -0x24(%rbp)
jmp 0x10ab4
movq -0x10(%rbp), %rax
addq $0x18, %rax
movq %rax, -0x30(%rbp)
movl $0xd, -0x24(%rbp)
movq -0x18(%rbp), %rdi
movl -0x24(%rbp), %esi
callq 0x102c0
movl %eax, -0x20(%rbp)
movq -0x30(%rbp), %rax
movslq -0x20(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
je 0x10b0d
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x10c0
cmpl $0x0, %eax
jne 0x10aff
movq -0x38(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x10b15
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x38(%rbp)
jmp 0x10ad3
movq $0x0, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/anuwu[P]ERPLAG-Compiler/symbolTable.c
// Function: searchVarModule
varST * searchVarModule ( moduleST * thisModule , char * lexeme ) 
{
	varST * tmp ;
	if((tmp = searchVarModuleList (thisModule , lexeme, SEARCH_LOCAL)))
		return tmp ;
	else if ((tmp = searchVarModuleList (thisModule, lexeme, SEARCH_INPUT)))
		return tmp ;
	else 
		return searchVarModuleList (thisModule, lexeme, SEARCH_OUTPUT) ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x2, %edx
callq 0x10a40
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x10b56
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x10b8f
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
xorl %edx, %edx
callq 0x10a40
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x10b79
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
jmp 0x10b8f
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x1, %edx
callq 0x10a40
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
cmpq 0x26449(%rip), %rax     # 0x37008
jne 0x10bd4
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
callq 0x10b20
movq %rax, -0x8(%rbp)
jmp 0x10c10
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
movl $0x2, %edx
callq 0x10a40
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x10c08
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x18(%rbp), %rsi
callq 0x10ba0
movq %rax, -0x8(%rbp)
jmp 0x10c10
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/anuwu[P]ERPLAG-Compiler/symbolTable.c
// Function: varTypeToString
char* varTypeToString (variableType varType)
{
	switch (varType)
	{
		case VAR_PLACEHOLDER :
			return "placeholder" ;
		case VAR_INPUT :
			return "input" ;
		case VAR_OUTPUT :
			return "output" ;
		case VAR_LOOP :
			return "loop" ;
		case VAR_MODULE :
			return "Module" ;
		case VAR_LOCAL :
			return "local" ;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movq %rax, -0x18(%rbp)
subq $0x5, %rax
ja 0x10c94
movq -0x18(%rbp), %rax
leaq 0x6b71(%rip), %rcx      # 0x177b0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x6b80(%rip), %rax      # 0x177cf
movq %rax, -0x8(%rbp)
jmp 0x10c94
leaq 0x6323(%rip), %rax      # 0x16f7f
movq %rax, -0x8(%rbp)
jmp 0x10c94
leaq 0x6b72(%rip), %rax      # 0x177db
movq %rax, -0x8(%rbp)
jmp 0x10c94
leaq 0x6b6c(%rip), %rax      # 0x177e2
movq %rax, -0x8(%rbp)
jmp 0x10c94
leaq 0x682e(%rip), %rax      # 0x174b1
movq %rax, -0x8(%rbp)
jmp 0x10c94
leaq 0x6b57(%rip), %rax      # 0x177e7
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
leaq 0x6b3e(%rip), %rdi      # 0x177ed
movb $0x0, %al
callq 0x1090
cmpq $0x0, 0x2634a(%rip)     # 0x37008
jne 0x10cc5
jmp 0x10deb
movq 0x2633c(%rip), %rax     # 0x37008
cmpq $0x0, 0xd0(%rax)
je 0x10ced
movq 0x2632b(%rip), %rax     # 0x37008
movq 0xd0(%rax), %rax
movq (%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0x10cfa
leaq 0x6072(%rip), %rax      # 0x16d66
movq %rax, -0x28(%rbp)
jmp 0x10cfa
movq -0x28(%rbp), %rsi
leaq 0x6b11(%rip), %rdi      # 0x17816
movb $0x0, %al
callq 0x1090
leaq 0x6b12(%rip), %rdi      # 0x17825
movb $0x0, %al
callq 0x1090
movl $0x0, -0x4(%rbp)
cmpl $0xd, -0x4(%rbp)
jge 0x10d75
movq 0x262da(%rip), %rax     # 0x37008
movslq -0x4(%rbp), %rcx
movq 0x68(%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x10d68
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rsi
leaq 0x6ae7(%rip), %rdi      # 0x1783a
movb $0x0, %al
callq 0x1090
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x10d3b
jmp 0x10d6a
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x10d21
leaq 0x6ac2(%rip), %rdi      # 0x1783e
movb $0x0, %al
callq 0x1090
movl $0x0, -0x14(%rbp)
cmpl $0xd, -0x14(%rbp)
jge 0x10ddd
movq 0x26271(%rip), %rax     # 0x37008
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x10dd0
movq -0x20(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rsi
leaq 0x6a7f(%rip), %rdi      # 0x1783a
movb $0x0, %al
callq 0x1090
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x10da3
jmp 0x10dd2
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x10d8a
leaq 0x6a71(%rip), %rdi      # 0x17855
movb $0x0, %al
callq 0x1090
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/anuwu[P]ERPLAG-Compiler/symbolTable.c
// Function: typeIDToString
char *typeIDToString (tokenID id)
{
	switch (id)
	{
		case TK_INTEGER :
			return "integer" ;
		case TK_BOOLEAN :
			return "boolean" ;
		case TK_REAL :
			return "real" ;
		default :
			return "" ;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0xc(%rbp)
movl -0xc(%rbp), %eax
movl %eax, -0x10(%rbp)
subl $0x37, %eax
je 0x12398
jmp 0x12384
movl -0x10(%rbp), %eax
subl $0x38, %eax
je 0x123b2
jmp 0x1238e
movl -0x10(%rbp), %eax
subl $0x39, %eax
je 0x123a5
jmp 0x123bf
leaq 0x4b75(%rip), %rax      # 0x16f14
movq %rax, -0x8(%rbp)
jmp 0x123ca
leaq 0x4b75(%rip), %rax      # 0x16f21
movq %rax, -0x8(%rbp)
jmp 0x123ca
leaq 0x4b63(%rip), %rax      # 0x16f1c
movq %rax, -0x8(%rbp)
jmp 0x123ca
leaq 0x2fd3(%rip), %rax      # 0x15399
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/anuwu[P]ERPLAG-Compiler/symbolTable.c
// Function: caseValRepeat
int caseValRepeat (astNode *caseAstNode)
{
	char *searchLex = caseAstNode->next->tok->lexeme ;

	caseAstNode = caseAstNode->prev->prev->prev ;
	while (caseAstNode)
	{
		if (strcmp(searchLex , caseAstNode->next->tok->lexeme) == 0)
			return 1 ;
		caseAstNode = caseAstNode->prev->prev->prev ;
	}

	return 0 ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x40(%rax), %rax
movq 0x40(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x12448
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x10c0
cmpl $0x0, %eax
jne 0x12432
movl $0x1, -0x4(%rbp)
jmp 0x1244f
movq -0x10(%rbp), %rax
movq 0x40(%rax), %rax
movq 0x40(%rax), %rax
movq 0x40(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x12404
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)