LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/anuwu[P]ERPLAG-Compiler/parser.c
// Function: push
stacknode * push(stacknode * stc , tokenID token){
	if(token == TK_EPS)
		return stc;
 
	stacknode * tmp = (stacknode *) malloc(sizeof(stacknode));
	tmp->key = token;
	tmp->next = stc;
	stc = tmp;
 
	return tmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
cmpl $0x36, %esi
je 0xa1fd
movl %esi, %r14d
pushq $0x10
popq %rdi
callq 0x1110
movl %r14d, (%rax)
movq %rbx, 0x8(%rax)
movq %rax, %rbx
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xa21b
movq 0x8(%rdi), %rbx
callq 0x1030
jmp 0xa229
leaq 0x647c(%rip), %rdi      # 0x1069e
callq 0x1070
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xa205
movq %rax, %rbx
callq 0xa1c0
movq %rax, %r14
movslq %r15d, %rax
shlq $0x4, %rax
movq 0x8(%r12,%rax), %r15
movl (%r15), %eax
movl %eax, (%r14)
movq 0x8(%r15), %r15
testq %r15, %r15
je 0xa298
movl (%r15), %esi
movq %r14, %rdi
callq 0xa1d9
movq %rax, %r14
jmp 0xa266
movl (%r14), %esi
movq %rbx, %rdi
callq 0xa1d9
movq %rax, %rbx
movq %r14, %rdi
callq 0xa205
movq %rax, %r14
testq %r14, %r14
jne 0xa27f
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x3f78(%rip), %r14      # 0xe232
testq %rbx, %rbx
je 0xa2d1
movl (%rbx), %esi
movq %r14, %rdi
xorl %eax, %eax
callq 0x10b0
movq 0x8(%rbx), %rbx
jmp 0xa2ba
pushq $0xa
popq %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O2/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, %rbx
movslq %edx, %rax
shlq $0x4, %rax
leaq (%rsi,%rax), %r13
addq $0x8, %r13
movq (%r13), %r13
testq %r13, %r13
je 0xa362
movl (%r13), %r14d
cmpq $0x35, %r14
ja 0xa326
movabsq $-0x100000000, %rax     # imm = 0xFFFFFFFF00000000
andq %rax, %r15
orq %r14, %r15
pushq $0x1
popq %r12
jmp 0xa346
cmpl $0x72, %r14d
ja 0xa346
pushq $0x18
popq %rdi
callq 0x1110
movq %rax, %r15
movl %r14d, (%rax)
andq $0x0, 0x8(%rax)
orl $-0x1, 0x10(%rax)
xorl %r12d, %r12d
movl %r12d, %edi
movq %r15, %rsi
callq 0xa0d0
movq %rbx, %rdi
movq %rax, %rsi
callq 0xa108
addq $0x8, %r13
jmp 0xa2fd
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xa7c7
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x28(%rdi), %rbx
callq 0x1030
testq %rbx, %rbx
je 0xa7c1
movq %rbx, %rdi
callq 0xa79a
movq 0x30(%rbx), %rbx
jmp 0xa7ae
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xa7e8
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
movsbl (%rdi), %ecx
testl %ecx, %ecx
je 0xa7e1
addl %ecx, %eax
incq %rdi
jmp 0xa7d3
cltd
idivl %esi
movl %edx, %eax
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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
xorl %eax, %eax
leaq 0x25808(%rip), %rcx     # 0x30000
movzbl (%rax,%rcx), %edx
cmpl $0x7a, %edx
jne 0xa80a
movb $0x61, (%rax,%rcx)
incq %rax
jmp 0xa7f8
testl %edx, %edx
jne 0xa81c
testl %eax, %eax
js 0xa821
movl %eax, %edx
movb $0x61, (%rdx,%rcx)
decl %eax
jmp 0xa80e
incb %dl
movb %dl, (%rax,%rcx)
leaq 0x257d8(%rip), %rax     # 0x30000
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/anuwu[P]ERPLAG-Compiler/symbolTable.c
// Function: createBaseST
baseST * createBaseST () 
{
	baseST * tmp = ( baseST *) malloc ( sizeof(baseST)) ;
	tmp->driverST =  NULL ;
	tmp->semanticError = 0 ;
	
	for ( int i = 0 ; i < MODULE_BIN_COUNT ; i++ ) {
		tmp->modules[i] = NULL ;
	}
	for ( int i = 0 ; i < LOCAL_BIN_COUNT ; i++ ) {
		tmp->vars[i] = NULL ;
	}
	return tmp ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0xe0, %edi
callq 0x1110
andq $0x0, 0xd0(%rax)
andl $0x0, 0xd8(%rax)
pushq $0xd
popq %rcx
cmpq $0x1a, %rcx
je 0xa85a
andq $0x0, (%rax,%rcx,8)
incq %rcx
jmp 0xa84a
xorl %ecx, %ecx
cmpq $0xd, %rcx
je 0xa86c
andq $0x0, (%rax,%rcx,8)
incq %rcx
jmp 0xa85c
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/anuwu[P]ERPLAG-Compiler/symbolTable.c
// Function: createModuleST
moduleST * createModuleST (void *parent, char * lexeme, int currOffset) 
{
	moduleST * tmp = ( moduleST *) malloc ( sizeof(moduleST)) ;

	tmp->lexeme = lexeme ;
	tmp->tableType = MODULE_ST ;

	for ( int i = 0 ; i < LOCAL_BIN_COUNT ; i++ ) {
		tmp->localVars[i] = NULL ;
		
	}

	for (int i = 0 ; i < IO_BIN_COUNT ; i++) {
		tmp->inputVars[i] = NULL ;
		tmp->outputVars[i] = NULL ;
	}

	for ( int i = 0 ; i < MODULE_BIN_COUNT ; i++ ) {
		tmp->scopeVars[i] = NULL ;
	}

	tmp->parent = parent ;
	tmp->currOffset = currOffset ;
	tmp->filledMod = 0 ;
	tmp->outputSize = 0 ;
	tmp->inputSize = 0 ;
	tmp->scopeSize = 0 ;

	return tmp ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
movl $0x118, %edi            # imm = 0x118
callq 0x1110
movq %r15, (%rax)
movl $0x1, 0x8(%rax)
pushq $0x3
popq %rcx
cmpq $0x10, %rcx
je 0xa8a7
andq $0x0, (%rax,%rcx,8)
incq %rcx
jmp 0xa897
xorps %xmm0, %xmm0
movups %xmm0, 0x88(%rax)
pushq $0x13
popq %rcx
cmpq $0x20, %rcx
je 0xa8c4
andq $0x0, (%rax,%rcx,8)
incq %rcx
jmp 0xa8b4
movq %r14, 0x10(%rax)
movl %ebx, 0x10c(%rax)
andq $0x0, 0x100(%rax)
andl $0x0, 0x108(%rax)
andl $0x0, 0x110(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
pushq $0x14
popq %rdi
callq 0x1110
movq %rax, %r15
callq 0xa7eb
leaq 0x256cc(%rip), %rsi     # 0x30000
movq %r15, %rdi
callq 0x1050
movl 0x10c(%r14), %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0xa86e
movl %ebx, 0x8(%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/anuwu[P]ERPLAG-Compiler/symbolTable.c
// Function: createVarST
varST * createVarST (char *lexeme, void *scope, variableType varType, tokenID datatype) 
{
	varST * tmp = (varST *) malloc ( sizeof(varST)) ;

	tmp->lexeme = lexeme ;
	tmp->datatype = datatype ;
	tmp->offset = 0 ; //default value
	tmp->size = 0 ;
	tmp->tinker = 0 ;
	tmp->arrayIndices = NULL ;
	tmp->scope = scope ;
	tmp->varType = varType ;

	return tmp ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %ecx, %ebx
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
pushq $0x38
popq %rdi
callq 0x1110
movq %r12, (%rax)
movl %ebx, 0x8(%rax)
xorps %xmm0, %xmm0
andl $0x0, 0x20(%rax)
movups %xmm0, 0x10(%rax)
movq %r15, 0x28(%rax)
movl %r14d, 0x30(%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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), %rdi
pushq $0xd
popq %rsi
callq 0xa7c8
movl %eax, %r14d
pushq $0x10
popq %rdi
callq 0x1110
movq %rbx, (%rax)
movq 0x25652(%rip), %rcx     # 0x30018
movslq %r14d, %rdx
movq 0x68(%rcx,%rdx,8), %rsi
movq %rsi, 0x8(%rax)
movq %rax, 0x68(%rcx,%rdx,8)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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), %rdi
pushq $0xd
popq %rsi
callq 0xa7c8
movl %eax, %r14d
pushq $0x10
popq %rdi
callq 0x1110
movq %rbx, (%rax)
movq 0x25612(%rip), %rcx     # 0x30018
movslq %r14d, %rdx
movq (%rcx,%rdx,8), %rsi
movq %rsi, 0x8(%rax)
movq %rax, (%rcx,%rdx,8)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, %rbx
movq %rdi, %r14
movq (%rsi), %rdi
pushq $0xd
popq %rsi
callq 0xa7c8
movl %eax, %r15d
pushq $0x10
popq %rdi
callq 0x1110
movq %rbx, (%rax)
movslq %r15d, %rcx
movq 0x98(%r14,%rcx,8), %rdx
movq %rdx, 0x8(%rax)
movq %rax, 0x98(%r14,%rcx,8)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0xd
popq %rsi
callq 0xa7c8
movslq %eax, %r15
shlq $0x3, %r15
addq 0x25538(%rip), %r15     # 0x30018
movq (%r15), %r15
testq %r15, %r15
je 0xab00
movq (%r15), %r14
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x10e0
addq $0x8, %r15
testl %eax, %eax
jne 0xaae0
jmp 0xab03
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0xd
popq %rsi
callq 0xa7c8
movq 0x254eb(%rip), %rcx     # 0x30018
cltq
leaq (%rcx,%rax,8), %r15
addq $0x68, %r15
movq (%r15), %r15
testq %r15, %r15
je 0xab5e
movq (%r15), %r14
cmpl $0x1, 0x8(%r14)
jne 0xab58
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x10e0
testl %eax, %eax
je 0xab61
addq $0x8, %r15
jmp 0xab37
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
movq %rdi, %r14
movslq %edx, %rax
leaq 0x5b4f(%rip), %rcx      # 0x106d8
leaq 0x5b60(%rip), %rdx      # 0x106f0
movl (%rdx,%rax,4), %esi
addq (%rcx,%rax,8), %r14
movq %rbx, %rdi
callq 0xa7c8
cltq
leaq (%r14,%rax,8), %r15
movq (%r15), %r15
testq %r15, %r15
je 0xabc5
movq (%r15), %r14
movq (%r14), %rdi
movq %rbx, %rsi
callq 0x10e0
addq $0x8, %r15
testl %eax, %eax
jne 0xaba5
jmp 0xabc8
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
movq %rsi, %rbx
movq 0x253ea(%rip), %r15     # 0x30018
pushq $0x2
popq %r14
movq 0x10(%rdi), %r12
cmpq %r15, %r12
je 0xac57
movq %rbx, %rsi
movl %r14d, %edx
callq 0xab6f
movq %r12, %rdi
testq %rax, %rax
je 0xac32
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xabd6
// File: /workspace/github_c_makefile_star2_O2/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 0x72ed(%rip), %rdi      # 0x11f89
callq 0x1070
movq 0x25370(%rip), %rax     # 0x30018
testq %rax, %rax
je 0xacbe
movq 0xd0(%rax), %rax
testq %rax, %rax
je 0xacc9
movq (%rax), %rsi
jmp 0xacd0
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4f22(%rip), %rsi      # 0xfbf2
leaq 0x5a62(%rip), %rdi      # 0x10739
xorl %eax, %eax
callq 0x10b0
leaq 0x72cc(%rip), %rdi      # 0x11fb1
callq 0x1070
leaq 0x5a57(%rip), %rbx      # 0x10748
xorl %r14d, %r14d
cmpq $0xd, %r14
je 0xad2c
movq 0x25317(%rip), %rax     # 0x30018
leaq (%rax,%r14,8), %r15
addq $0x68, %r15
movq (%r15), %r15
testq %r15, %r15
je 0xad27
movq (%r15), %rax
movq (%rax), %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x10b0
addq $0x8, %r15
jmp 0xad09
incq %r14
jmp 0xacf4
leaq 0x7292(%rip), %rdi      # 0x11fc5
callq 0x1070
leaq 0x5a09(%rip), %rbx      # 0x10748
xorl %r14d, %r14d
cmpq $0xd, %r14
je 0xad7a
leaq (,%r14,8), %r15
addq 0x252c1(%rip), %r15     # 0x30018
movq (%r15), %r15
testq %r15, %r15
je 0xad75
movq (%r15), %rax
movq (%rax), %rsi
movq %rbx, %rdi
xorl %eax, %eax
callq 0x10b0
addq $0x8, %r15
jmp 0xad57
incq %r14
jmp 0xad42
leaq 0x729e(%rip), %rdi      # 0x1201f
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1070
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
testq %rbx, %rbx
je 0xbc9f
movq 0x8(%rbx), %rax
movq 0x8(%rax), %rsi
movq %r14, %rdi
callq 0xac19
testq %rax, %rax
je 0xbc99
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0xbbf1
movq 0x38(%rbx), %rbx
jmp 0xbc71
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
movq %rsp, %rbp
addq $0x90, %rdi
movq (%rdi), %rcx
testq %rcx, %rcx
je 0xbcc4
movq (%rcx), %rax
leaq 0x8(%rcx), %rdi
cmpl $0x0, 0x20(%rax)
jne 0xbcaf
xorl %eax, %eax
testq %rcx, %rcx
sete %al
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rdi, %rbx
addq $0x90, %rbx
leaq 0x5871(%rip), %r14      # 0x1155a
leaq 0x4880(%rip), %r15      # 0x10570
movq (%rbx), %rbx
testq %rbx, %rbx
je 0xbd32
movq (%rbx), %rax
cmpl $0x0, 0x20(%rax)
je 0xbd07
addq $0x8, %rbx
jmp 0xbcf0
movq (%rax), %rsi
movq %r14, %rdi
xorl %eax, %eax
callq 0x10b0
movq 0x8(%rbx), %rax
testq %rax, %rax
je 0xbd01
movq (%rax), %rax
cmpl $0x0, 0x20(%rax)
jne 0xbd01
movq %r15, %rdi
xorl %eax, %eax
callq 0x10b0
jmp 0xbd01
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xbd6c
movq %rdi, %r14
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
jne 0xbd4b
pushq $0x10
popq %rdi
callq 0x1110
movl %ebx, (%rax)
andq $0x0, 0x8(%rax)
movq %rax, 0x8(%r14)
jmp 0xbd6e
movl %ebx, (%rdi)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/anuwu[P]ERPLAG-Compiler/symbolTable.c
// Function: getExprVars
void getExprVars (moduleST *baseModule, guardTinkerNode *tinkerHead, astNode *exprNode)
{
	if (exprNode == NULL)
		return ;

	if (exprNode->child == NULL || exprNode->child->next == NULL)	// array[index]
	{
		varST *searchedVar, *searchedVarIndex ;

		searchedVar = searchVar (baseModule, exprNode->tok->lexeme) ;
		if (searchedVar != NULL)
			addTinkerList (tinkerHead, searchedVar->tinker) ;

		if (exprNode->child != NULL && exprNode->child->id == TK_ID)
		{
			searchedVarIndex = searchVar (baseModule, exprNode->child->tok->lexeme) ;
			if (searchedVarIndex != NULL)
				addTinkerList (tinkerHead, searchedVarIndex->tinker) ;
		}
	}
	else
	{
		getExprVars (baseModule, tinkerHead, exprNode->child) ;
		if (exprNode->child != NULL)
			getExprVars (baseModule, tinkerHead, exprNode->child->next) ;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %rbx
movq %rdi, %r14
testq %r15, %r15
je 0xbe17
movq 0x30(%r15), %r12
testq %r12, %r12
je 0xbdbe
cmpq $0x0, 0x38(%r12)
je 0xbdbe
movq %r14, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0xbd73
movq 0x30(%r15), %rax
testq %rax, %rax
je 0xbe17
movq 0x38(%rax), %r15
jmp 0xbd87
movq 0x8(%r15), %rax
movq 0x8(%rax), %rsi
movq %r14, %rdi
callq 0xac19
testq %rax, %rax
je 0xbde2
movl 0x20(%rax), %esi
movq %rbx, %rdi
callq 0xbd3d
movq 0x30(%r15), %r12
testq %r12, %r12
je 0xbe17
cmpl $0x40, (%r12)
jne 0xbe17
movq 0x8(%r12), %rax
movq 0x8(%rax), %rsi
movq %r14, %rdi
callq 0xac19
testq %rax, %rax
je 0xbe17
movl 0x20(%rax), %esi
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xbd3d
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
pushq $0x10
popq %rdi
callq 0x1110
movq %rax, %r15
orl $-0x1, (%rax)
andq $0x0, 0x8(%rax)
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0xbd73
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
movq %rsp, %rbp
movl $0x1, %ecx
xorl %eax, %eax
testq %rdi, %rdi
je 0xbe86
testq %rsi, %rsi
je 0xbe86
movl (%rsi), %eax
cmpl (%rdi), %eax
jg 0xbe84
movq 0x8(%rsi), %rsi
movq 0x8(%rdi), %rdi
jmp 0xbe68
movl %ecx, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
cmpl $0x71, (%rsi)
jne 0xcda6
pushq $0x71
jmp 0xcdc6
movq %rsi, %rbx
movq %rdi, %r14
movq 0x8(%rsi), %rax
movq 0x8(%rax), %rsi
callq 0xac19
testq %rax, %rax
je 0xcdca
cmpl $0x37, 0x8(%rax)
jne 0xcdd3
pushq $0x40
popq %r15
jmp 0xce18
leaq 0x52a7(%rip), %r12      # 0x12078
jmp 0xcdda
leaq 0x52fa(%rip), %r12      # 0x120d4
xorl %r15d, %r15d
xorl %eax, %eax
callq 0xd671
movq %r14, %rdi
callq 0xb395
movq 0x8(%rbx), %rcx
movl 0x10(%rcx), %edx
movq 0x8(%rcx), %rcx
movq %r12, %rdi
movq %rax, %rsi
xorl %eax, %eax
callq 0x10b0
leaq 0x2320d(%rip), %rax     # 0x30018
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_O2/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 0x1130
movl %eax, %r12d
movq 0x10(%rbx), %r13
movq 0x8(%r13), %rax
movq 0x8(%rax), %rdi
callq 0x1130
cmpl %eax, %r12d
jl 0xce73
movq 0x10(%r13), %rax
movq 0x8(%rax), %rdi
callq 0x1130
cmpl %eax, %r12d
jle 0xceba
xorl %r12d, %r12d
xorl %eax, %eax
callq 0xd671
movq %r15, %rdi
callq 0xb395
movq 0x8(%r14), %rcx
movl 0x10(%rcx), %edx
movq 0x8(%rcx), %rcx
movq (%rbx), %r8
leaq 0x52a4(%rip), %rdi      # 0x1213e
movq %rax, %rsi
xorl %eax, %eax
callq 0x10b0
leaq 0x2316d(%rip), %rax     # 0x30018
movq (%rax), %rax
movl $0x1, 0xd8(%rax)
jmp 0xcebe
pushq $0x1
popq %r12
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_O2/Tarsnap[P]libcperciva/tests/fork_func/../../util/parsenum.h
// Function: parsenum_signed
static inline intmax_t
parsenum_signed(const char * s, intmax_t min, intmax_t max, int base,
    int trailing)
{
	char * eptr;
	intmax_t val;

	/* Sanity check. */
	assert(s != NULL);

	val = strtoimax(s, &eptr, base);
	if (eptr == s || (!trailing && (*eptr != '\0')))
		errno = EINVAL;
	else if ((val < min) || (val > max)) {
		errno = ERANGE;
		val = 0;
	}
	return (val);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1704
movq %rdi, %r14
movq %rsp, %r15
movq %r15, %rsi
xorl %edx, %edx
callq 0x1040
movq %rax, %rbx
movq (%r15), %rax
pushq $0x16
popq %rbp
cmpq %r14, %rax
je 0x16ef
cmpb $0x0, (%rax)
jne 0x16ef
cmpq $0x2711, %rbx           # imm = 0x2711
jb 0x16f6
pushq $0x22
popq %rbp
xorl %ebx, %ebx
callq 0x1080
movl %ebp, (%rax)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x1c9e(%rip), %rdi      # 0x33a9
leaq 0x194e(%rip), %rsi      # 0x3060
leaq 0x195d(%rip), %rcx      # 0x3076
movl $0xa7, %edx
callq 0x1110
// File: /workspace/github_c_makefile_star2_O2/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 %r15
pushq %r14
pushq %rbx
pushq %rax
xorl %ebx, %ebx
leaq 0x49(%rip), %r14        # 0x1831
leaq 0x4(%rsp), %r15
pushq $-0x1
popq %rbp
xorl %ecx, %ecx
movl %ecx, 0x4(%rsp)
cmpl $0x3, %ecx
jg 0x1824
movq %r14, %rdi
movq %r15, %rsi
callq 0x1c40
cmpl $-0x1, %eax
je 0x1822
movl %eax, %edi
callq 0x1c9f
cmpl $-0x1, %eax
je 0x1822
movl 0x4(%rsp), %edx
leal 0x1(%rdx), %ecx
cmpl %edx, %eax
je 0x17f2
movl %ebp, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x3792(%rip), %r14      # 0x4fd8
leaq 0x38f3(%rip), %r15      # 0x5140
leaq 0x18c7(%rip), %rbx      # 0x311b
xorl %r12d, %r12d
movq (%r14), %rdi
cmpq $0x14, %r12
je 0x188c
movl (%r12,%r15), %edx
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1160
addq $0x4, %r12
testl %eax, %eax
jns 0x1857
callq 0x1080
cmpl $0x0, (%rax)
je 0x18e3
movq %rax, %rbx
leaq 0x18b3(%rip), %rdi      # 0x313d
jmp 0x18a9
callq 0x1180
testl %eax, %eax
je 0x18b5
callq 0x1080
cmpl $0x0, (%rax)
je 0x18ec
movq %rax, %rbx
leaq 0x189c(%rip), %rdi      # 0x3145
xorl %eax, %eax
callq 0x2861
andl $0x0, (%rbx)
jmp 0x18fa
xorl %r12d, %r12d
leaq 0x6b(%rip), %r14        # 0x192a
pushq $-0x1
popq %rbx
cmpq $0x14, %r12
je 0x190b
leaq (%r15,%r12), %rsi
movq %r14, %rdi
callq 0x1c40
movl %eax, (%rsp,%r12)
addq $0x4, %r12
cmpl $-0x1, %eax
jne 0x18c2
jmp 0x18fd
leaq 0x1853(%rip), %rdi      # 0x313d
jmp 0x18f3
leaq 0x1852(%rip), %rdi      # 0x3145
xorl %eax, %eax
callq 0x29f0
pushq $-0x1
popq %rbx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
xorl %r14d, %r14d
cmpq $0x5, %r14
je 0x1926
movl (%rsp,%r14,4), %edi
callq 0x1c9f
incq %r14
testl %eax, %eax
je 0x190e
jmp 0x18fd
xorl %ebx, %ebx
jmp 0x18fd
// File: /workspace/github_c_makefile_star2_O2/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 0x3694(%rip), %rax      # 0x4ff8
movq (%rax), %rdi
leaq 0x17de(%rip), %rsi      # 0x314c
movl %r14d, %edx
xorl %eax, %eax
callq 0x1160
testl %eax, %eax
jns 0x19ad
callq 0x1080
cmpl $0x0, (%rax)
je 0x199c
movq %rax, %rbx
leaq 0x17ad(%rip), %rdi      # 0x313d
xorl %eax, %eax
callq 0x2861
andl $0x0, (%rbx)
jmp 0x19aa
leaq 0x179a(%rip), %rdi      # 0x313d
xorl %eax, %eax
callq 0x29f0
pushq $-0x1
popq %rbx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O2/Tarsnap[P]libcperciva/tests/fork_func/check_perftest.c
// Function: check_perftest
int
check_perftest(int child_ms, int num_reps)
{
	int i;

	/* Explain columns. */
	printf("# type\textra_delay\n");

	/* Baseline: time the delay without any threads or processes. */
	for (i = 0; i < num_reps; i++)
		if (benchmark_only_millisleep(child_ms))
			goto err0;

	/* Time the delay with pthread. */
	for (i = 0; i < num_reps; i++)
		if (benchmark_pthread_millisleep(child_ms))
			goto err0;

	/* Time the delay with fork_func. */
	for (i = 0; i < num_reps; i++)
		if (benchmark_fork_func_millisleep(child_ms))
			goto err0;

	/* Success! */
	return (0);

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %esi, %r13d
movl %edi, %ebp
leaq 0x17d4(%rip), %rdi      # 0x31a6
callq 0x10b0
xorl %eax, %eax
testl %r13d, %r13d
cmovlel %eax, %r13d
movslq %ebp, %r14
leaq 0x28(%rsp), %r15
leaq 0x18(%rsp), %r12
movl %r13d, %ebx
subl $0x1, %ebx
jb 0x1a3d
movq %r15, %rdi
callq 0x25e8
testl %eax, %eax
jne 0x1b4b
movq %r14, %rdi
callq 0x1c03
movq %r12, %rdi
callq 0x25e8
testl %eax, %eax
jne 0x1b4b
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %r8
xorl %edi, %edi
movl %ebp, %r9d
callq 0x1bc6
jmp 0x19f0
leaq 0x28(%rsp), %r14
leaq 0x10(%rsp), %r12
leaq 0xc(%rsp), %r15
movl %r13d, %ebx
subl $0x1, %ebx
jb 0x1acd
movl %ebp, 0xc(%rsp)
movq %r14, %rdi
callq 0x25e8
testl %eax, %eax
jne 0x1b4b
movq %r12, %rdi
xorl %esi, %esi
leaq 0x1bf(%rip), %rdx       # 0x1c33
movq %r15, %rcx
callq 0x11b0
testl %eax, %eax
jne 0x1b7b
movq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0x1210
testl %eax, %eax
jne 0x1b84
leaq 0x18(%rsp), %rdi
callq 0x25e8
testl %eax, %eax
jne 0x1b4b
movl 0xc(%rsp), %r9d
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %r8
pushq $0x1
popq %rdi
callq 0x1bc6
jmp 0x1a4f
leaq 0x28(%rsp), %r14
leaq 0xe0(%rip), %r15        # 0x1bb9
leaq 0x10(%rsp), %r12
leaq 0x18(%rsp), %rbx
subl $0x1, %r13d
jb 0x1bac
movl %ebp, 0x10(%rsp)
movq %r14, %rdi
callq 0x25e8
testl %eax, %eax
jne 0x1b4b
movq %r15, %rdi
movq %r12, %rsi
callq 0x1c40
cmpl $-0x1, %eax
je 0x1bb0
movl %eax, %edi
callq 0x1c9f
testl %eax, %eax
jne 0x1b9a
movq %rbx, %rdi
callq 0x25e8
testl %eax, %eax
jne 0x1b4b
movl 0x10(%rsp), %r9d
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %r8
pushq $0x2
popq %rdi
callq 0x1bc6
jmp 0x1ae3
callq 0x1080
cmpl $0x0, (%rax)
je 0x1b6b
movq %rax, %rbx
leaq 0x1611(%rip), %rdi      # 0x3170
xorl %eax, %eax
callq 0x2861
andl $0x0, (%rbx)
jmp 0x1b9a
leaq 0x15fe(%rip), %rdi      # 0x3170
xorl %eax, %eax
callq 0x29f0
jmp 0x1b9a
leaq 0x1605(%rip), %rdi      # 0x3187
jmp 0x1b8b
leaq 0x1604(%rip), %rdi      # 0x318f
xorl %eax, %eax
callq 0x29f0
callq 0x1080
andl $0x0, (%rax)
pushq $-0x1
popq %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
xorl %eax, %eax
jmp 0x1b9d
leaq 0x15e5(%rip), %rdi      # 0x319c
jmp 0x1b8b
// File: /workspace/github_c_makefile_star2_O2/Tarsnap[P]libcperciva/tests/fork_func/../../util/millisleep.h
// Function: millisleep
static inline void
millisleep(size_t msec)
{
	struct timespec ts;

	ts.tv_sec = msec / 1000;
	ts.tv_nsec = (msec % 1000) * 1000000;
	nanosleep(&ts, NULL);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, %rax
movl $0x3e8, %ecx            # imm = 0x3E8
xorl %edx, %edx
divq %rcx
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
imulq $0xf4240, %rdx, %rax    # imm = 0xF4240
movq %rax, 0x8(%rdi)
xorl %esi, %esi
callq 0x1100
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O2/codeniko[P]CS214-Malloc-Free/Test10.c
// Function: main
void main()
{
    void* p = malloc(sizeof(int));
    *((int*)p) = 5;
    printf("integer: address: %p, value: %d\n", p, *((int*)p));
    free(p);
    char* c = "Hello World"; 
    p = malloc(sizeof(char) * (strlen(c) + 1));
    memcpy(p, c, strlen(c));
    printf("String: address: %p, value: %s\n", p, (char*)p);
    free(p);
    p = malloc(sizeof(float));
    *((float*)p) = 1.2345;
    printf("float: address: %p, value: %f\n", p, *((float*)p));
    free(p);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0xeb3(%rip), %rbx       # 0x2010
pushq $0x4
popq %r14
pushq $0x8
popq %rdx
movl %r14d, %edi
movq %rbx, %rsi
callq 0x122c
movq %rax, %r15
movl $0x5, (%rax)
leaq 0xe9a(%rip), %rdi       # 0x2019
pushq $0x5
popq %rdx
movq %rax, %rsi
xorl %eax, %eax
callq 0x1030
pushq $0xb
popq %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1365
pushq $0xc
popq %rdi
pushq $0xd
popq %rdx
movq %rbx, %rsi
callq 0x122c
movq %rax, %r15
movabsq $0x6f57206f6c6c6548, %rax # imm = 0x6F57206F6C6C6548
movq %rax, (%r15)
movl $0x646c726f, 0x7(%r15)  # imm = 0x646C726F
leaq 0xe7f(%rip), %rdi       # 0x2046
movq %r15, %rsi
movq %r15, %rdx
xorl %eax, %eax
callq 0x1030
pushq $0x10
popq %rdx
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1365
pushq $0x11
popq %rdx
movl %r14d, %edi
movq %rbx, %rsi
callq 0x122c
movq %rax, %r14
movl $0x3f9e0419, (%rax)     # imm = 0x3F9E0419
leaq 0xe66(%rip), %rdi       # 0x2066
movsd 0xe00(%rip), %xmm0      # 0x2008
movq %rax, %rsi
movb $0x1, %al
callq 0x1030
pushq $0x14
popq %rdx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1365
nop
// File: /workspace/github_c_makefile_star2_O2/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_4/exercise_4_07/ungets.c
// Function: main
int main(void)
{
  char line[MAXLEN];
  char temp[MAXLEN];

  getstr(line, MAXLEN);
  printf("%s", line);

  ungetstr(line);

  getstr(temp, MAXLEN);
  printf("%s", temp);

  return 0;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x7d8, %rsp            # imm = 0x7D8
leaq 0x3f0(%rsp), %rbx
movq %rbx, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x11d1
leaq 0xe72(%rip), %r14       # 0x2004
movq %r14, %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1050
movq %rbx, %rdi
callq 0x121b
movq %rsp, %rbx
movq %rbx, %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x11d1
movq %r14, %rdi
movq %rbx, %rsi
xorl %eax, %eax
callq 0x1050
xorl %eax, %eax
addq $0x7d8, %rsp            # imm = 0x7D8
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/ohkimur[P]the-c-programming-language-2nd-edition-solutions/chapter_4/exercise_4_07/ungets.c
// Function: getstr
int getstr(char line[], int limit)
{
  int i = 0, c;

  while (limit - 1 > 0 && (c = getch()) != EOF && c != '\n')
  {
    line[i++] = c;
  }

  if (c == '\n')
  {
    line[i++] = c;
  }

  line[i] = '\0';

  return i;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
xorl %r14d, %r14d
cmpl $0x2, %ebp
jl 0x11ff
callq 0x1249
cmpl $-0x1, %eax
je 0x11fa
cmpl $0xa, %eax
je 0x11fa
movb %al, (%rbx,%r14)
incq %r14
jmp 0x11dd
cmpl $0xa, %eax
jne 0x120d
movl %r14d, %eax
incl %eax
movl %r14d, %ecx
movb $0xa, (%rbx,%rcx)
jmp 0x1210
movl %r14d, %eax
cltq
movb $0x0, (%rbx,%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/simh[P]simtools/extracters/ckabstape/ckabstape.c
// Function: printb
void printb(unsigned char c)
{
	int i;
	for(i=0; i<8; i++){
	 if((c & 0x80) == 0)
	  printf("%c",'0');
	 else
	  printf("%c",'1');
	 c = c << 1;
	}
	printf("\n");
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edi, %ebx
pushq $0x8
popq %rbp
subl $0x1, %ebp
jb 0x11bb
xorl %edi, %edi
testb %bl, %bl
setns %dil
xorl $0x31, %edi
callq 0x1030
addb %bl, %bl
jmp 0x11a2
pushq $0xa
popq %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O2/simh[P]simtools/extracters/ckabstape/ckabstape.c
// Function: readframe
unsigned int readframe()
{
	unsigned int i;
	unsigned char c;
	do{
	 c = getchar(); 
	 if(feof(stdin)) 
	  exit(0);
	  if((c & 0x80) == 0) printf("{nul}\n");
	} while((c & 0x80) == 0);

	i =    ((c & 0xc0)>>6)<<27;
	i = i | (c & 0x3f)<<12;
	do{
	 c = getchar(); 
	 if(feof(stdin)) 
	  exit(0);
	  if((c & 0x80) == 0) printf("{nul}\n");
	} while((c & 0x80) == 0);

	i = i |((c & 0xc0)>>6)<<24;
	i = i | (c & 0x3f)<<6;

	do{
	 c = getchar(); 
	 if(feof(stdin)) 
	  exit(0);
	  if((c & 0x80) == 0) printf("{nul}\n");
	} while((c & 0x80) == 0);

	i = i |((c & 0xc0)>>6)<<21;
	i = i | (c & 0x3f);
	return i;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq 0x2e08(%rip), %r12      # 0x3fe0
leaq 0x13b5(%rip), %r14      # 0x2594
callq 0x1060
movl %eax, %ebx
movq (%r12), %rdi
callq 0x1070
testl %eax, %eax
jne 0x12a5
testb %bl, %bl
js 0x1205
movq %r14, %rdi
callq 0x1040
jmp 0x11df
leaq 0x1388(%rip), %r14      # 0x2594
callq 0x1060
movl %eax, %ebp
movq (%r12), %rdi
callq 0x1070
testl %eax, %eax
jne 0x12a5
testb %bpl, %bpl
js 0x1233
movq %r14, %rdi
callq 0x1040
jmp 0x120c
leaq 0x135a(%rip), %r15      # 0x2594
callq 0x1060
movl %eax, %r14d
movq (%r12), %rdi
callq 0x1070
testl %eax, %eax
jne 0x12a5
testb %r14b, %r14b
js 0x125e
movq %r15, %rdi
callq 0x1040
jmp 0x123a
movl %ebx, %eax
shll $0x15, %eax
andl $0x18000000, %eax       # imm = 0x18000000
andl $0x3f, %ebx
shll $0xc, %ebx
orl %eax, %ebx
movl %ebp, %eax
shll $0x12, %eax
andl $0x3000000, %eax        # imm = 0x3000000
orl %ebx, %eax
andl $0x3f, %ebp
shll $0x6, %ebp
orl %eax, %ebp
movl %r14d, %eax
shll $0xf, %eax
andl $0x600000, %eax         # imm = 0x600000
andl $0x3f, %r14d
orl %ebp, %r14d
orl %eax, %r14d
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
xorl %edi, %edi
callq 0x1080
// File: /workspace/github_c_makefile_star2_O2/USArmyResearchLab[P]ARL_OpenSHMEM/src/autogen/shmem_alltoall64.c
// Function: shmem_alltoall64
void shmem_alltoall64( void* dest, const void* source, size_t nelems,
	int pe_start, int log_pe_stride, int pe_size, long* psync)
{
	debug("[%d] shmem_alltoall_x begin\n",__shmem.my_pe);
	int j;
	int dst_offset = ((__shmem.my_pe - pe_start) >> log_pe_stride)*nelems;
	int pe_size_stride = pe_size << log_pe_stride;
	int step = 1 << log_pe_stride;
	int pe_end = pe_size_stride + pe_start;
	int64_t* psrc = (int64_t*)source;
	int64_t* pdsto = (int64_t*)dest + dst_offset;
	shmemx_memcpy((void*)pdsto, (void*)psrc, nelems*sizeof(int64_t));
	for (j = 1; j < pe_size; j++) {
		int pe_to = __shmem.my_pe + j*step;
		if (pe_to >= pe_end) pe_to -= pe_size_stride;
		int64_t* pdst = (int64_t*)shmem_ptr(pdsto, pe_to);
		shmemx_memcpy((void*)pdst, (void*)psrc, nelems*sizeof(int64_t));
	}
	debug("[%d] shmem_alltoall_x before barrier\n",__shmem.my_pe);
	shmem_barrier(pe_start, log_pe_stride, pe_size, psync);
	debug("[%d] shmem_alltoall_x end\n",__shmem.my_pe);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, %r10d
leaq 0x331c(%rip), %rax      # 0x6200
movl 0x4(%rax), %eax
subl %ecx, %eax
movl %r8d, %ecx
sarl %cl, %eax
movq 0x50(%rsp), %rcx
movq %rcx, 0x8(%rsp)
movl %edx, %r11d
imull %eax, %r11d
movl %r9d, 0x4(%rsp)
movl %r9d, %r14d
movl %r8d, (%rsp)
movl %r8d, %ecx
shll %cl, %r14d
movq %r10, 0x10(%rsp)
leal (%r14,%r10), %ebx
movslq %r11d, %rax
leaq (%rdi,%rax,8), %r13
shlq $0x3, %rdx
movq %r13, %rdi
movq %rsi, %r15
movq %rdx, %rbp
callq 0x3048
pushq $0x1
popq %r12
cmpl 0x4(%rsp), %r12d
jge 0x2f7a
movl %r12d, %esi
movl (%rsp), %ecx
shll %cl, %esi
leaq 0x32b3(%rip), %rax      # 0x6200
addl 0x4(%rax), %esi
cmpl %ebx, %esi
movl %r14d, %eax
movl $0x0, %ecx
cmovll %ecx, %eax
subl %eax, %esi
movq %r13, %rdi
callq 0x1c5c
movq %rax, %rdi
movq %r15, %rsi
movq %rbp, %rdx
callq 0x3048
incl %r12d
jmp 0x2f37
movq 0x10(%rsp), %rdi
movl (%rsp), %esi
movl 0x4(%rsp), %edx
movq 0x8(%rsp), %rcx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2fa0
nop
// File: /workspace/github_c_makefile_star2_O2/nilyang[P]redis-tdd-annotation/src/redis-check-dump.c
// Function: checkType
int checkType(unsigned char t) {
    /* In case a new object type is added, update the following 
     * condition as necessary. */
    return
        (t >= REDIS_HASH_ZIPMAP && t <= REDIS_HASH_ZIPLIST) ||
        t <= REDIS_HASH ||
        t >= REDIS_EXPIRETIME_MS;
}

// Assembly:
cmpb $0xe, %dil
jae 0x1284
movzbl %dil, %eax
movl $0x3e1f, %ecx           # imm = 0x3E1F
btl %eax, %ecx
jae 0x1284
pushq $0x1
popq %rax
retq
xorl %eax, %eax
cmpb $-0x4, %dil
setae %al
retq