LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/anuwu[P]ERPLAG-Compiler/symbolTable.c
// Function: tinkerVar
void tinkerVar (moduleST *baseModule, varST *var, astNode *varASTNode)
{
	var->tinker++ ;
	if (var->varType == VAR_LOOP)
	{
		errSemantic () ;
		#ifdef _WIN64
			printf ("In module \"%s\" at line %d, loop variable \"%s\" cannot be modified\n", getParentModuleName (baseModule), varASTNode->tok->lineNumber, varASTNode->tok->lexeme) ;
		#endif
		#if defined __linux__ || __MACH__
			printf ("In module " ANSI_BOLD "%s" ANSI_RESET " at line " ANSI_BOLD ANSI_CYAN "%d" ANSI_RESET ", " ANSI_BOLD ANSI_BLACK "loop" ANSI_RESET " variable " ANSI_BOLD ANSI_RED "%s" ANSI_RESET " cannot be modified\n", getParentModuleName (baseModule), varASTNode->tok->lineNumber, varASTNode->tok->lexeme) ;
		#endif
		realBase->semanticError = 1 ;
	}
	else if (var->varType == VAR_PLACEHOLDER)
	{
		errSemantic () ;
		#ifdef _WIN64
			printf ("In module \"%s\" at line %d, placeholder variable \"%s\" cannot be modified\n", getParentModuleName (baseModule), varASTNode->tok->lineNumber, varASTNode->tok->lexeme) ;
		#endif
		#if defined __linux__ || __MACH__
			printf ("In module " ANSI_BOLD "%s" ANSI_RESET " at line " ANSI_BOLD ANSI_CYAN "%d" ANSI_RESET ", " ANSI_BOLD ANSI_BLACK "placeholder" ANSI_RESET " variable " ANSI_BOLD ANSI_RED "%s" ANSI_RESET " cannot be modified\n", getParentModuleName (baseModule), varASTNode->tok->lineNumber, varASTNode->tok->lexeme) ;
		#endif
		realBase->semanticError = 1 ;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movl 0x20(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x20(%rax)
movq -0x10(%rbp), %rax
cmpl $0x4, 0x30(%rax)
jne 0x124d6
movb $0x0, %al
callq 0x14d10
movq -0x8(%rbp), %rdi
callq 0x116e0
movq %rax, %rsi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x10(%rax), %edx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rcx
leaq 0x6137(%rip), %rdi      # 0x185f3
movb $0x0, %al
callq 0x1090
movq 0x24b3e(%rip), %rax     # 0x37008
movl $0x1, 0xd8(%rax)
jmp 0x1252b
movq -0x10(%rbp), %rax
cmpl $0x1, 0x30(%rax)
jne 0x12529
movb $0x0, %al
callq 0x14d10
movq -0x8(%rbp), %rdi
callq 0x116e0
movq %rax, %rsi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x10(%rax), %edx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rcx
leaq 0x614f(%rip), %rdi      # 0x18660
movb $0x0, %al
callq 0x1090
movq 0x24ae9(%rip), %rax     # 0x37008
movl $0x1, 0xd8(%rax)
jmp 0x1252b
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x12596
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x10ba0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x12588
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x12460
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x12550
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpl $0x1, -0x14(%rbp)
jge 0x12601
movq -0x10(%rbp), %rax
movslq -0x14(%rbp), %rcx
movq 0x90(%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x125f4
movq -0x20(%rbp), %rax
movq (%rax), %rax
cmpl $0x0, 0x20(%rax)
jne 0x125e6
movl $0x0, -0x4(%rbp)
jmp 0x12608
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x125c9
jmp 0x125f6
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x125af
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0x1, -0xc(%rbp)
jge 0x126b7
movq -0x8(%rbp), %rax
movslq -0xc(%rbp), %rcx
movq 0x90(%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0x126a7
movq -0x18(%rbp), %rax
movq (%rax), %rax
cmpl $0x0, 0x20(%rax)
jne 0x12699
movq -0x18(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rsi
leaq 0x606e(%rip), %rdi      # 0x186d4
movb $0x0, %al
callq 0x1090
movq -0x18(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x12697
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rax
cmpl $0x0, 0x20(%rax)
jne 0x12697
leaq 0x4fea(%rip), %rdi      # 0x1767a
movb $0x0, %al
callq 0x1090
jmp 0x12699
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x12641
jmp 0x126a9
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x12623
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
cmpl $-0x1, (%rax)
jne 0x126e3
movl -0xc(%rbp), %ecx
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
jmp 0x1272d
jmp 0x126e5
movq -0x8(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0x126fe
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x126e5
movl $0x10, %edi
callq 0x10e0
movq %rax, -0x18(%rbp)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x8(%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: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x12760
jmp 0x12839
movq -0x18(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x1277e
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
cmpq $0x0, 0x38(%rax)
jne 0x127fe
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x10ba0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
je 0x127ae
movq -0x10(%rbp), %rdi
movq -0x20(%rbp), %rax
movl 0x20(%rax), %esi
callq 0x126c0
movq -0x18(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x127fc
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
cmpl $0x40, (%rax)
jne 0x127fc
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x10ba0
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0x127fa
movq -0x10(%rbp), %rdi
movq -0x28(%rbp), %rax
movl 0x20(%rax), %esi
callq 0x126c0
jmp 0x127fc
jmp 0x12839
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rdx
callq 0x12740
movq -0x18(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0x12837
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rsi
movq -0x18(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x38(%rax), %rdx
callq 0x12740
jmp 0x12839
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x10, %edi
callq 0x10e0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
movq -0x18(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
callq 0x12740
movq -0x18(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
xorl %eax, %eax
cmpq $0x0, -0x10(%rbp)
movb %al, -0x19(%rbp)
je 0x128b3
cmpq $0x0, -0x18(%rbp)
setne %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x128bc
jmp 0x128ed
movq -0x18(%rbp), %rax
movl (%rax), %eax
movq -0x10(%rbp), %rcx
cmpl (%rcx), %eax
jle 0x128d3
movl $0x1, -0x4(%rbp)
jmp 0x128f4
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x1289c
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpl $0x71, (%rax)
jne 0x14035
movl $0x71, -0x4(%rbp)
jmp 0x14112
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x10ba0
movq %rax, -0x20(%rbp)
cmpq $0x0, -0x20(%rbp)
jne 0x140aa
movb $0x0, %al
callq 0x14d10
movq -0x10(%rbp), %rdi
callq 0x116e0
movq %rax, %rsi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x10(%rax), %edx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rcx
leaq 0x507d(%rip), %rdi      # 0x19103
movb $0x0, %al
callq 0x1090
leaq 0x22f74(%rip), %rax     # 0x37008
movq (%rax), %rax
movl $0x1, 0xd8(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x14112
movq -0x20(%rbp), %rax
cmpl $0x37, 0x8(%rax)
je 0x14109
movb $0x0, %al
callq 0x14d10
movq -0x10(%rbp), %rdi
callq 0x116e0
movq %rax, %rsi
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x10(%rax), %edx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rcx
leaq 0x507a(%rip), %rdi      # 0x1915f
movb $0x0, %al
callq 0x1090
leaq 0x22f15(%rip), %rax     # 0x37008
movq (%rax), %rax
movl $0x1, 0xd8(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x14112
jmp 0x1410b
movl $0x40, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x1100
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x1100
movl %eax, -0x28(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rdi
callq 0x1100
movl %eax, -0x2c(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x28(%rbp), %eax
jl 0x14188
movl -0x24(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jle 0x141e4
movb $0x0, %al
callq 0x14d10
movq -0x10(%rbp), %rdi
callq 0x116e0
movq %rax, %rsi
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movl 0x10(%rax), %edx
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rcx
movq -0x18(%rbp), %rax
movq (%rax), %r8
leaq 0x5009(%rip), %rdi      # 0x191c9
movb $0x0, %al
callq 0x1090
leaq 0x22e3a(%rip), %rax     # 0x37008
movq (%rax), %rax
movl $0x1, 0xd8(%rax)
movl $0x0, -0x4(%rbp)
jmp 0x141eb
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/tests/fork_func/check_exec.c
// Function: check_exec
int
check_exec(void)
{
	pid_t pid;

	/* Fork. */
	if ((pid = fork_func(func_exec, NULL)) == -1)
		goto err0;

	/* Check that it didn't fail. */
	if (fork_func_wait(pid) != 0)
		goto err0;

	/* Success! */
	return (0);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
leaq 0x41(%rip), %rdi        # 0x1c20
xorl %eax, %eax
movl %eax, %esi
callq 0x24c0
movl %eax, -0x8(%rbp)
cmpl $-0x1, %eax
jne 0x1bf2
jmp 0x1c0a
movl -0x8(%rbp), %edi
callq 0x2560
cmpl $0x0, %eax
je 0x1c01
jmp 0x1c0a
movl $0x0, -0x4(%rbp)
jmp 0x1c11
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movl $0x0, -0xc(%rbp)
cmpl $0x4, -0xc(%rbp)
jge 0x1ce8
leaq 0x64(%rip), %rdi        # 0x1d10
leaq -0xc(%rbp), %rsi
callq 0x24c0
movl %eax, -0x8(%rbp)
cmpl $-0x1, %eax
jne 0x1cbf
jmp 0x1cf1
movl -0x8(%rbp), %edi
callq 0x2560
movl %eax, -0x10(%rbp)
cmpl $-0x1, %eax
jne 0x1cd1
jmp 0x1cf1
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
je 0x1cdb
jmp 0x1cf1
jmp 0x1cdd
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1c9f
movl $0x0, -0x4(%rbp)
jmp 0x1cf8
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x24(%rbp)
cmpl $0x5, -0x24(%rbp)
jge 0x1db9
movq 0x428c(%rip), %rax      # 0x5fd8
movq (%rax), %rdi
movslq -0x24(%rbp), %rcx
leaq 0x43d6(%rip), %rax      # 0x6130
movl (%rax,%rcx,4), %edx
leaq 0x24b5(%rip), %rsi      # 0x4219
movb $0x0, %al
callq 0x1140
cmpl $0x0, %eax
jge 0x1dac
jmp 0x1d72
callq 0x1080
cmpl $0x0, (%rax)
je 0x1d97
leaq 0x24b8(%rip), %rdi      # 0x423b
movb $0x0, %al
callq 0x3740
callq 0x1080
movl $0x0, (%rax)
jmp 0x1da5
leaq 0x249d(%rip), %rdi      # 0x423b
movb $0x0, %al
callq 0x3990
jmp 0x1da7
jmp 0x1e84
jmp 0x1dae
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1d3f
movq 0x4218(%rip), %rax      # 0x5fd8
movq (%rax), %rdi
callq 0x1160
cmpl $0x0, %eax
je 0x1e06
jmp 0x1dcf
callq 0x1080
cmpl $0x0, (%rax)
je 0x1df4
leaq 0x2463(%rip), %rdi      # 0x4243
movb $0x0, %al
callq 0x3740
callq 0x1080
movl $0x0, (%rax)
jmp 0x1e02
leaq 0x2448(%rip), %rdi      # 0x4243
movb $0x0, %al
callq 0x3990
jmp 0x1e04
jmp 0x1e84
movl $0x0, -0x24(%rbp)
cmpl $0x5, -0x24(%rbp)
jge 0x1e4d
movslq -0x24(%rbp), %rax
leaq 0x4312(%rip), %rsi      # 0x6130
shlq $0x2, %rax
addq %rax, %rsi
leaq 0x74(%rip), %rdi        # 0x1ea0
callq 0x24c0
movslq -0x24(%rbp), %rcx
movl %eax, -0x20(%rbp,%rcx,4)
cmpl $-0x1, %eax
jne 0x1e40
jmp 0x1e84
jmp 0x1e42
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1e0d
movl $0x0, -0x24(%rbp)
cmpl $0x5, -0x24(%rbp)
jge 0x1e7b
movslq -0x24(%rbp), %rax
movl -0x20(%rbp,%rax,4), %edi
callq 0x2560
cmpl $0x0, %eax
je 0x1e6e
jmp 0x1e84
jmp 0x1e70
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x1e54
movl $0x0, -0x4(%rbp)
jmp 0x1e8b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x14(%rbp)
movslq -0x14(%rbp), %rdi
callq 0x1f30
movq 0x4133(%rip), %rax      # 0x5ff8
movq (%rax), %rdi
movl -0x14(%rbp), %edx
leaq 0x2378(%rip), %rsi      # 0x424a
movb $0x0, %al
callq 0x1140
cmpl $0x0, %eax
jge 0x1f17
jmp 0x1ee0
callq 0x1080
cmpl $0x0, (%rax)
je 0x1f05
leaq 0x234a(%rip), %rdi      # 0x423b
movb $0x0, %al
callq 0x3740
callq 0x1080
movl $0x0, (%rax)
jmp 0x1f13
leaq 0x232f(%rip), %rdi      # 0x423b
movb $0x0, %al
callq 0x3990
jmp 0x1f15
jmp 0x1f20
movl $0x0, -0x4(%rbp)
jmp 0x1f27
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
leaq 0x22d3(%rip), %rdi      # 0x4268
movb $0x0, %al
callq 0x10f0
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x1fc7
movl -0x8(%rbp), %edi
callq 0x2040
cmpl $0x0, %eax
je 0x1fba
jmp 0x2026
jmp 0x1fbc
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1fa3
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x1ff2
movl -0x8(%rbp), %edi
callq 0x2120
cmpl $0x0, %eax
je 0x1fe5
jmp 0x2026
jmp 0x1fe7
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1fce
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x201d
movl -0x8(%rbp), %edi
callq 0x2260
cmpl $0x0, %eax
je 0x2010
jmp 0x2026
jmp 0x2012
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1ff9
movl $0x0, -0x4(%rbp)
jmp 0x202d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/tests/fork_func/check_perftest.c
// Function: benchmark_only_millisleep
static int
benchmark_only_millisleep(int ms)
{
	struct timeval tv_orig, tv_now;

	/* Get the original time. */
	if (monoclock_get(&tv_orig)) {
		warnp("monoclock_get");
		goto err0;
	}

	/* Wait. */
	millisleep_func(&ms);

	/* Get the current time, and print the difference. */
	if (monoclock_get(&tv_now)) {
		warnp("monoclock_get");
		goto err0;
	}
	print_timediff(0, tv_orig, tv_now, ms);

	/* Success! */
	return (0);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x3360
cmpl $0x0, %eax
je 0x2092
jmp 0x205b
callq 0x1080
cmpl $0x0, (%rax)
je 0x2080
leaq 0x2210(%rip), %rdi      # 0x427c
movb $0x0, %al
callq 0x3740
callq 0x1080
movl $0x0, (%rax)
jmp 0x208e
leaq 0x21f5(%rip), %rdi      # 0x427c
movb $0x0, %al
callq 0x3990
jmp 0x2090
jmp 0x2106
leaq -0x8(%rbp), %rdi
callq 0x2380
leaq -0x28(%rbp), %rdi
callq 0x3360
cmpl $0x0, %eax
je 0x20e2
jmp 0x20ab
callq 0x1080
cmpl $0x0, (%rax)
je 0x20d0
leaq 0x21c0(%rip), %rdi      # 0x427c
movb $0x0, %al
callq 0x3740
callq 0x1080
movl $0x0, (%rax)
jmp 0x20de
leaq 0x21a5(%rip), %rdi      # 0x427c
movb $0x0, %al
callq 0x3990
jmp 0x20e0
jmp 0x2106
movl -0x8(%rbp), %r9d
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %r8
xorl %edi, %edi
callq 0x23b0
movl $0x0, -0x4(%rbp)
jmp 0x210d
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/tests/fork_func/check_perftest.c
// Function: benchmark_pthread_millisleep
static int
benchmark_pthread_millisleep(int ms)
{
	struct timeval tv_orig, tv_now;
	pthread_t thr;

	/* Get the original time. */
	if (monoclock_get(&tv_orig)) {
		warnp("monoclock_get");
		goto err0;
	}

	/* Create a new thread and wait for it to finish. */
	if (pthread_create(&thr, NULL, millisleep_func_pthread, &ms)) {
		warn0("pthread");
		goto err0;
	}
	if (pthread_join(thr, NULL)) {
		warn0("pthread_join");
		goto err0;
	}

	/* Get the current time, and print the difference. */
	if (monoclock_get(&tv_now)) {
		warnp("monoclock_get");
		goto err0;
	}
	print_timediff(1, tv_orig, tv_now, ms);

	/* Success! */
	return (0);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x3360
cmpl $0x0, %eax
je 0x2175
jmp 0x213b
callq 0x1080
cmpl $0x0, (%rax)
je 0x2160
leaq 0x2130(%rip), %rdi      # 0x427c
movb $0x0, %al
callq 0x3740
callq 0x1080
movl $0x0, (%rax)
jmp 0x216e
leaq 0x2115(%rip), %rdi      # 0x427c
movb $0x0, %al
callq 0x3990
jmp 0x2170
jmp 0x224f
leaq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
leaq 0x30c(%rip), %rdx       # 0x2490
leaq -0x8(%rbp), %rcx
callq 0x1190
cmpl $0x0, %eax
je 0x21b2
jmp 0x2194
leaq 0x20f8(%rip), %rdi      # 0x4293
movb $0x0, %al
callq 0x3990
callq 0x1080
movl $0x0, (%rax)
jmp 0x224f
movq -0x30(%rbp), %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x11f0
cmpl $0x0, %eax
je 0x21e1
jmp 0x21c6
leaq 0x20ce(%rip), %rdi      # 0x429b
movb $0x0, %al
callq 0x3990
callq 0x1080
movl $0x0, (%rax)
jmp 0x224f
leaq -0x28(%rbp), %rdi
callq 0x3360
cmpl $0x0, %eax
je 0x2228
jmp 0x21f1
callq 0x1080
cmpl $0x0, (%rax)
je 0x2216
leaq 0x207a(%rip), %rdi      # 0x427c
movb $0x0, %al
callq 0x3740
callq 0x1080
movl $0x0, (%rax)
jmp 0x2224
leaq 0x205f(%rip), %rdi      # 0x427c
movb $0x0, %al
callq 0x3990
jmp 0x2226
jmp 0x224f
movl -0x8(%rbp), %r9d
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %r8
movl $0x1, %edi
callq 0x23b0
movl $0x0, -0x4(%rbp)
jmp 0x2256
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/Tarsnap[P]libcperciva/tests/fork_func/check_perftest.c
// Function: benchmark_fork_func_millisleep
static int
benchmark_fork_func_millisleep(int ms)
{
	struct timeval tv_orig, tv_now;
	pid_t pid;

	/* Get the original time. */
	if (monoclock_get(&tv_orig)) {
		warnp("monoclock_get");
		goto err0;
	}

	/* Create a new process, and wait for it to finish. */
	if ((pid = fork_func(millisleep_func, &ms)) == -1) {
		warn0("fork_func");
		goto err0;
	}
	if (fork_func_wait(pid))
		goto err0;

	/* Get the current time, and print the difference. */
	if (monoclock_get(&tv_now)) {
		warnp("monoclock_get");
		goto err0;
	}
	print_timediff(2, tv_orig, tv_now, ms);

	/* Success! */
	return (0);

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movl %edi, -0x8(%rbp)
leaq -0x18(%rbp), %rdi
callq 0x3360
cmpl $0x0, %eax
je 0x22b5
jmp 0x227b
callq 0x1080
cmpl $0x0, (%rax)
je 0x22a0
leaq 0x1ff0(%rip), %rdi      # 0x427c
movb $0x0, %al
callq 0x3740
callq 0x1080
movl $0x0, (%rax)
jmp 0x22ae
leaq 0x1fd5(%rip), %rdi      # 0x427c
movb $0x0, %al
callq 0x3990
jmp 0x22b0
jmp 0x2367
leaq 0xc4(%rip), %rdi        # 0x2380
leaq -0x8(%rbp), %rsi
callq 0x24c0
movl %eax, -0x2c(%rbp)
cmpl $-0x1, %eax
jne 0x22ea
jmp 0x22cf
leaq 0x1fd2(%rip), %rdi      # 0x42a8
movb $0x0, %al
callq 0x3990
callq 0x1080
movl $0x0, (%rax)
jmp 0x2367
movl -0x2c(%rbp), %edi
callq 0x2560
cmpl $0x0, %eax
je 0x22f9
jmp 0x2367
leaq -0x28(%rbp), %rdi
callq 0x3360
cmpl $0x0, %eax
je 0x2340
jmp 0x2309
callq 0x1080
cmpl $0x0, (%rax)
je 0x232e
leaq 0x1f62(%rip), %rdi      # 0x427c
movb $0x0, %al
callq 0x3740
callq 0x1080
movl $0x0, (%rax)
jmp 0x233c
leaq 0x1f47(%rip), %rdi      # 0x427c
movb $0x0, %al
callq 0x3990
jmp 0x233e
jmp 0x2367
movl -0x8(%rbp), %r9d
movq -0x18(%rbp), %rsi
movq -0x10(%rbp), %rdx
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %r8
movl $0x2, %edi
callq 0x23b0
movl $0x0, -0x4(%rbp)
jmp 0x236e
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movl $0x4, %edi
leaq 0xe84(%rip), %rsi       # 0x2008
movl $0x8, %edx
callq 0x12c0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x5, (%rax)
movq -0x8(%rbp), %rsi
movq -0x8(%rbp), %rax
movl (%rax), %edx
leaq 0xe64(%rip), %rdi       # 0x2011
movb $0x0, %al
callq 0x1040
movq -0x8(%rbp), %rdi
leaq 0xe49(%rip), %rsi       # 0x2008
movl $0xb, %edx
callq 0x14c0
leaq 0xe62(%rip), %rax       # 0x2032
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1030
addq $0x1, %rax
shlq $0x0, %rax
movl %eax, %edi
leaq 0xe1a(%rip), %rsi       # 0x2008
movl $0xd, %edx
callq 0x12c0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rdi
callq 0x1030
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq %rax, %rdx
callq 0x1060
movq -0x8(%rbp), %rsi
movq -0x8(%rbp), %rdx
leaq 0xe0a(%rip), %rdi       # 0x203e
movb $0x0, %al
callq 0x1040
movq -0x8(%rbp), %rdi
leaq 0xdc2(%rip), %rsi       # 0x2008
movl $0x10, %edx
callq 0x14c0
movl $0x4, %edi
leaq 0xdac(%rip), %rsi       # 0x2008
movl $0x11, %edx
callq 0x12c0
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movss 0xd8e(%rip), %xmm0      # 0x2004
movss %xmm0, (%rax)
movq -0x8(%rbp), %rsi
movq -0x8(%rbp), %rax
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
leaq 0xdcd(%rip), %rdi       # 0x205e
movb $0x1, %al
callq 0x1040
movq -0x8(%rbp), %rdi
leaq 0xd65(%rip), %rsi       # 0x2008
movl $0x14, %edx
callq 0x14c0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x7e0, %rsp            # imm = 0x7E0
movl $0x0, -0x4(%rbp)
leaq -0x3f0(%rbp), %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x11e0
leaq -0x3f0(%rbp), %rsi
leaq 0xe73(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1040
leaq -0x3f0(%rbp), %rdi
callq 0x1280
leaq -0x7e0(%rbp), %rdi
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x11e0
leaq -0x7e0(%rbp), %rsi
leaq 0xe41(%rip), %rdi       # 0x2004
movb $0x0, %al
callq 0x1040
xorl %eax, %eax
addq $0x7e0, %rsp            # imm = 0x7E0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl $0x0, -0x10(%rbp)
movl -0xc(%rbp), %ecx
subl $0x1, %ecx
xorl %eax, %eax
cmpl $0x0, %ecx
movb %al, -0x15(%rbp)
jle 0x1224
callq 0x12c0
movl %eax, %ecx
movl %ecx, -0x14(%rbp)
xorl %eax, %eax
cmpl $-0x1, %ecx
movb %al, -0x15(%rbp)
je 0x1224
cmpl $0xa, -0x14(%rbp)
setne %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x122d
jmp 0x1249
movl -0x14(%rbp), %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x10(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
jmp 0x11f6
cmpl $0xa, -0x14(%rbp)
jne 0x1269
movl -0x14(%rbp), %eax
movb %al, %dl
movq -0x8(%rbp), %rax
movl -0x10(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x10(%rbp)
movslq %ecx, %rcx
movb %dl, (%rax,%rcx)
movq -0x8(%rbp), %rax
movslq -0x10(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0x10(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/shaswata56[P]BenchUtil/BenchmarkIOPS32.c
// Function: main
int main (int argc, char** argv) {
    int n;
    if (argc == 1) {
        printf("Number of CPU cores to run Benchmark: ");
        scanf("%d", &n);
    } else {
        n = atoi(argv[1]);
    }
    printf("Benchmarking for 32 Bit Integer operations per second\n");
    initIOPS32(n);
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpl $0x1, -0x8(%rbp)
jne 0x121e
leaq 0xe05(%rip), %rdi       # 0x2008
movb $0x0, %al
callq 0x1050
leaq 0xe1e(%rip), %rdi       # 0x202f
leaq -0x14(%rbp), %rsi
movb $0x0, %al
callq 0x10b0
jmp 0x122e
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x10a0
movl %eax, -0x14(%rbp)
leaq 0xdfd(%rip), %rdi       # 0x2032
movb $0x0, %al
callq 0x1050
movl -0x14(%rbp), %edi
callq 0x1250
xorl %eax, %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
movb %dil, %al
movb %al, -0x1(%rbp)
movl $0x0, -0x8(%rbp)
cmpl $0x8, -0x8(%rbp)
jge 0x11f5
movzbl -0x1(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
jne 0x11ce
leaq 0x1e44(%rip), %rdi      # 0x3004
movl $0x30, %esi
movb $0x0, %al
callq 0x1030
jmp 0x11e1
leaq 0x1e2f(%rip), %rdi      # 0x3004
movl $0x31, %esi
movb $0x0, %al
callq 0x1030
movzbl -0x1(%rbp), %eax
shll %eax
movb %al, -0x1(%rbp)
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x11a5
leaq 0x223a(%rip), %rdi      # 0x3436
movb $0x0, %al
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x10, %rsp
callq 0x1040
movb %al, -0x5(%rbp)
movq 0x3db9(%rip), %rax      # 0x4fe0
movq (%rax), %rdi
callq 0x1050
cmpl $0x0, %eax
je 0x123b
xorl %edi, %edi
callq 0x1060
movzbl -0x5(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
jne 0x1257
leaq 0x1db7(%rip), %rdi      # 0x3007
movb $0x0, %al
callq 0x1030
jmp 0x1259
movzbl -0x5(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x1218
movzbl -0x5(%rbp), %eax
andl $0xc0, %eax
sarl $0x6, %eax
shll $0x1b, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
movzbl -0x5(%rbp), %ecx
andl $0x3f, %ecx
shll $0xc, %ecx
orl %ecx, %eax
movl %eax, -0x4(%rbp)
callq 0x1040
movb %al, -0x5(%rbp)
movq 0x3d46(%rip), %rax      # 0x4fe0
movq (%rax), %rdi
callq 0x1050
cmpl $0x0, %eax
je 0x12ae
xorl %edi, %edi
callq 0x1060
movzbl -0x5(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
jne 0x12ca
leaq 0x1d44(%rip), %rdi      # 0x3007
movb $0x0, %al
callq 0x1030
jmp 0x12cc
movzbl -0x5(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x128b
movl -0x4(%rbp), %eax
movzbl -0x5(%rbp), %ecx
andl $0xc0, %ecx
sarl $0x6, %ecx
shll $0x18, %ecx
orl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
movzbl -0x5(%rbp), %ecx
andl $0x3f, %ecx
shll $0x6, %ecx
orl %ecx, %eax
movl %eax, -0x4(%rbp)
callq 0x1040
movb %al, -0x5(%rbp)
movq 0x3ccd(%rip), %rax      # 0x4fe0
movq (%rax), %rdi
callq 0x1050
cmpl $0x0, %eax
je 0x1327
xorl %edi, %edi
callq 0x1060
movzbl -0x5(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
jne 0x1343
leaq 0x1ccb(%rip), %rdi      # 0x3007
movb $0x0, %al
callq 0x1030
jmp 0x1345
movzbl -0x5(%rbp), %eax
andl $0x80, %eax
cmpl $0x0, %eax
je 0x1304
movl -0x4(%rbp), %eax
movzbl -0x5(%rbp), %ecx
andl $0xc0, %ecx
sarl $0x6, %ecx
shll $0x15, %ecx
orl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
movzbl -0x5(%rbp), %ecx
andl $0x3f, %ecx
orl %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x60, %rsp
movq 0x10(%rbp), %rax
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
leaq 0x2ed6(%rip), %rax      # 0x71f0
movl 0x4(%rax), %eax
subl -0x1c(%rbp), %eax
movl -0x20(%rbp), %ecx
sarl %cl, %eax
cltq
imulq -0x18(%rbp), %rax
movl %eax, -0x2c(%rbp)
movl -0x24(%rbp), %eax
movl -0x20(%rbp), %ecx
shll %cl, %eax
movl %eax, -0x30(%rbp)
movl -0x20(%rbp), %ecx
movl $0x1, %eax
shll %cl, %eax
movl %eax, -0x34(%rbp)
movl -0x30(%rbp), %eax
addl -0x1c(%rbp), %eax
movl %eax, -0x38(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x8(%rbp), %rax
movslq -0x2c(%rbp), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x48(%rbp)
movq -0x48(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x18(%rbp), %rdx
shlq $0x3, %rdx
callq 0x4500
movl $0x1, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x43e8
leaq 0x2e5a(%rip), %rax      # 0x71f0
movl 0x4(%rax), %eax
movl -0x28(%rbp), %ecx
imull -0x34(%rbp), %ecx
addl %ecx, %eax
movl %eax, -0x4c(%rbp)
movl -0x4c(%rbp), %eax
cmpl -0x38(%rbp), %eax
jl 0x43b8
movl -0x30(%rbp), %ecx
movl -0x4c(%rbp), %eax
subl %ecx, %eax
movl %eax, -0x4c(%rbp)
movq -0x48(%rbp), %rdi
movl -0x4c(%rbp), %esi
callq 0x2120
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq -0x18(%rbp), %rdx
shlq $0x3, %rdx
callq 0x4500
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x4387
movl -0x1c(%rbp), %edi
movl -0x20(%rbp), %esi
movl -0x24(%rbp), %edx
movq 0x10(%rbp), %rcx
callq 0x4400
addq $0x60, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x1(%rbp)
movzbl -0x1(%rbp), %eax
cmpl $0x9, %eax
jl 0x1281
movzbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0xd, %ecx
movb %al, -0x2(%rbp)
jle 0x129e
movzbl -0x1(%rbp), %ecx
movb $0x1, %al
cmpl $0x4, %ecx
movb %al, -0x2(%rbp)
jle 0x129e
movzbl -0x1(%rbp), %eax
cmpl $0xfc, %eax
setge %al
movb %al, -0x2(%rbp)
movb -0x2(%rbp), %al
andb $0x1, %al
movzbl %al, %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/src/redis-check-dump.c
// Function: readBytes
int readBytes(void *target, long num) {
    char peek = (num < 0) ? 1 : 0;
    num = (num < 0) ? -num : num;

    pos p = positions[level];
    if (p.offset + num > p.size) {
        return 0;
    } else {
        memcpy(target, (void*)((size_t)p.data + p.offset), num);
        if (!peek) positions[level].offset += num;
    }
    return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x18(%rbp), %rdx
xorl %eax, %eax
movl $0x1, %ecx
cmpq $0x0, %rdx
cmovll %ecx, %eax
movb %al, -0x19(%rbp)
cmpq $0x0, -0x18(%rbp)
jge 0x12e8
xorl %eax, %eax
subq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
jmp 0x12f0
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x18(%rbp)
movzbl 0x5f51(%rip), %eax      # 0x7250
movl %eax, %ecx
leaq 0x5dc8(%rip), %rax      # 0x70d0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rcx
movq %rcx, -0x38(%rbp)
movq 0x8(%rax), %rcx
movq %rcx, -0x30(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
addq -0x18(%rbp), %rax
cmpq -0x30(%rbp), %rax
jbe 0x133d
movl $0x0, -0x4(%rbp)
jmp 0x1384
movq -0x10(%rbp), %rdi
movq -0x38(%rbp), %rsi
addq -0x28(%rbp), %rsi
movq -0x18(%rbp), %rdx
callq 0x10d0
cmpb $0x0, -0x19(%rbp)
jne 0x137b
movq -0x18(%rbp), %rcx
movzbl 0x5eed(%rip), %eax      # 0x7250
movl %eax, %edx
leaq 0x5d64(%rip), %rax      # 0x70d0
imulq $0x18, %rdx, %rdx
addq %rdx, %rax
addq 0x10(%rax), %rcx
movq %rcx, 0x10(%rax)
jmp 0x137d
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/src/redis-check-dump.c
// Function: processHeader
int processHeader() {
    char buf[10] = "_________";
    int dump_version;

    if (!readBytes(buf, 9)) {
        ERROR("Cannot read header\n");
    }

    /* expect the first 5 bytes to equal REDIS */
    if (memcmp(buf,"REDIS",5) != 0) {
        ERROR("Wrong signature in header\n");
    }

    dump_version = (int)strtol(buf + 5, NULL, 10);
    if (dump_version < 1 || dump_version > 6) {
        ERROR("Unknown RDB format version: %d\n", dump_version);
    }
    return dump_version;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq 0x2cb1(%rip), %rax      # 0x4050
movq %rax, -0xa(%rbp)
movw 0x2cae(%rip), %ax       # 0x4058
movw %ax, -0x2(%rbp)
leaq -0xa(%rbp), %rdi
movl $0x9, %esi
callq 0x12b0
cmpl $0x0, %eax
jne 0x13d9
leaq 0x2c92(%rip), %rdi      # 0x405a
movb $0x0, %al
callq 0x1080
movl $0x1, %edi
callq 0x1130
leaq -0xa(%rbp), %rdi
leaq 0x2c8a(%rip), %rsi      # 0x406e
movl $0x5, %edx
callq 0x10b0
cmpl $0x0, %eax
je 0x140b
leaq 0x2c7a(%rip), %rdi      # 0x4074
movb $0x0, %al
callq 0x1080
movl $0x1, %edi
callq 0x1130
leaq -0xa(%rbp), %rdi
addq $0x5, %rdi
xorl %eax, %eax
movl %eax, %esi
movl $0xa, %edx
callq 0x10c0
movl %eax, -0x10(%rbp)
cmpl $0x1, -0x10(%rbp)
jl 0x1430
cmpl $0x6, -0x10(%rbp)
jle 0x144b
movl -0x10(%rbp), %esi
leaq 0x2c55(%rip), %rdi      # 0x408f
movb $0x0, %al
callq 0x1080
movl $0x1, %edi
callq 0x1130
movl -0x10(%rbp), %eax
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/nilyang[P]redis-tdd-annotation/src/redis-check-dump.c
// Function: loadType
int loadType(entry *e) {
    uint32_t offset = CURR_OFFSET;

    /* this byte needs to qualify as type */
    unsigned char t;
    if (readBytes(&t, 1)) {
        if (checkType(t)) {
            e->type = t;
            return 1;
        } else {
            SHIFT_ERROR(offset, "Unknown type (0x%02x)", t);
        }
    } else {
        SHIFT_ERROR(offset, "Could not read type");
    }

    /* failure */
    return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movzbl 0x5ddd(%rip), %eax      # 0x7250
movl %eax, %ecx
leaq 0x5c54(%rip), %rax      # 0x70d0
imulq $0x18, %rcx, %rcx
addq %rcx, %rax
movq 0x10(%rax), %rax
movl %eax, -0x14(%rbp)
leaq -0x15(%rbp), %rdi
movl $0x1, %esi
callq 0x12b0
cmpl $0x0, %eax
je 0x1518
movzbl -0x15(%rbp), %edi
callq 0x1260
cmpl $0x0, %eax
je 0x14c2
movzbl -0x15(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, 0x8(%rax)
movl $0x1, -0x4(%rbp)
jmp 0x156f
movq 0x9e0f(%rip), %rax      # 0xb2d8
leaq 0x5d88(%rip), %rdi      # 0x7258
shlq $0xa, %rax
addq %rax, %rdi
movzbl -0x15(%rbp), %edx
leaq 0x2bcd(%rip), %rsi      # 0x40af
movb $0x0, %al
callq 0x1120
movl -0x14(%rbp), %eax
movl %eax, %edx
movq 0x9de3(%rip), %rcx      # 0xb2d8
leaq 0x5d5c(%rip), %rax      # 0x7258
movq %rdx, 0x4000(%rax,%rcx,8)
movq 0x9dcd(%rip), %rax      # 0xb2d8
addq $0x1, %rax
movq %rax, 0x9dc2(%rip)      # 0xb2d8
jmp 0x1568
movq 0x9db9(%rip), %rax      # 0xb2d8
leaq 0x5d32(%rip), %rdi      # 0x7258
shlq $0xa, %rax
addq %rax, %rdi
leaq 0x2b91(%rip), %rsi      # 0x40c5
movb $0x0, %al
callq 0x1120
movl -0x14(%rbp), %eax
movl %eax, %edx
movq 0x9d91(%rip), %rcx      # 0xb2d8
leaq 0x5d0a(%rip), %rax      # 0x7258
movq %rdx, 0x4000(%rax,%rcx,8)
movq 0x9d7b(%rip), %rax      # 0xb2d8
addq $0x1, %rax
movq %rax, 0x9d70(%rip)      # 0xb2d8
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)