LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/anuwu[P]ERPLAG-Compiler/codegen.c
// Function: arrBoundCheck
void arrBoundCheck (astNode *node, moduleST *lst, varST *vst)
{
	varST *indexVar = NULL ;
	if (!isIndexStatic (node))	
		indexVar = searchVar (lst, node->child->tok->lexeme) ;

	tf |= 1 << boundCheck ;

	loadArrBase (vst, "RDI") ;
	loadRegLeftLim (vst, "BX") ;

	if (indexVar == NULL)
		codePrint ("\t\tMOV CX, %s\n", node->child->tok->lexeme) ;
	else
		codePrint ("\t\tMOV CX, [RBP%s]\n", getOffsetStr (indexVar->offset)) ;

	loadRegRightLim (vst, "DX") ;

	codePrint ("\t\tCALL @boundCheck") ;
	codeComment (10, "checking array index bound") ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
callq 0x1180
movq (%rax), %rax
movq 0x30(%r14), %rcx
movq 0x8(%rcx), %rcx
movq 0x8(%rcx), %rsi
movsbq (%rsi), %rcx
testb $0x8, 0x1(%rax,%rcx,2)
jne 0x17fa
movq %r15, %rdi
callq 0xb8e8
movq %rax, %r15
jmp 0x17fd
xorl %r15d, %r15d
orb $0x20, 0x15b65(%rip)    # 0x17369
leaq 0xdb04(%rip), %rsi      # 0xf30f
movq %rbx, %rdi
callq 0x16d5
leaq 0xdf40(%rip), %rsi      # 0xf75a
movq %rbx, %rdi
callq 0x1603
leaq 0x15b1f(%rip), %r13     # 0x17348
movq (%r13), %r12
testq %r15, %r15
je 0x184b
movl 0x1c(%r15), %edi
callq 0x1580
leaq 0xda2d(%rip), %rsi      # 0xf26f
leaq 0x15b27(%rip), %rdx     # 0x17370
jmp 0x185e
movq 0x30(%r14), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdx
leaq 0xda03(%rip), %rsi      # 0xf261
movq %r12, %rdi
xorl %eax, %eax
callq 0x1100
leaq 0xda13(%rip), %rsi      # 0xf282
movq %rbx, %rdi
callq 0x166c
movq (%r13), %rcx
leaq 0xda03(%rip), %rdi      # 0xf285
movl $0x12, %esi
movl $0x1, %edx
callq 0x1170
leaq 0xda00(%rip), %rsi      # 0xf298
movl $0xa, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x152e
// File: /workspace/github_c_makefile_star2_O3/anuwu[P]ERPLAG-Compiler/codegen.c
// Function: isArrayRHS
int isArrayRHS (astNode *assignNode, moduleST *lst)
{
	varST *searchedVar ;

	if (assignNode->child->next->id == TK_ID)
	{
		searchedVar = searchVar (lst, assignNode->child->next->tok->lexeme) ;
		if (searchedVar->datatype == TK_ARRAY && assignNode->child->next->child == NULL)
			return 1 ;
	}

	return 0 ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x30(%rdi), %rax
movq 0x38(%rax), %rax
cmpl $0x40, (%rax)
jne 0x194e
movq %rdi, %rbx
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq %rsi, %rdi
movq %rax, %rsi
callq 0xb8e8
cmpl $0x3b, 0x8(%rax)
jne 0x194e
movq 0x30(%rbx), %rax
movq 0x38(%rax), %rax
cmpq $0x0, 0x30(%rax)
je 0x1957
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl $0x1, %eax
jmp 0x1950
// File: /workspace/github_c_makefile_star2_O3/anuwu[P]ERPLAG-Compiler/codegen.c
// Function: dynAsgnArr
void dynAsgnArr (varST *lhs, varST *rhs)
{
	tf |= 1 << asgnLimERROR ;
	int leftLab, rightLab ;

	leftLab = get_label (LABEL_OTHER) ;
	rightLab = get_label (LABEL_OTHER) ;

	loadRegLeftLim (lhs, "AX") ;
	loadRegLeftLim (rhs, "CX") ;

	codePrint ("\t\tCMP AX, CX\n") ;
	codePrint ("\t\tJE @LABEL%d\n", leftLab) ;
	codePrint ("\t\tCALL @asgnLimERROR\n") ;

	codePrint ("\n\t@LABEL%d:\n", leftLab) ;
	loadRegRightLim (lhs, "BX") ;
	loadRegRightLim (rhs, "DX") ;

	codePrint ("\t\tCMP BX, DX\n") ;
	codePrint ("\t\tJE @LABEL%d\n", rightLab) ;
	codePrint ("\t\tCALL @asgnLimERROR\n") ;

	codePrint ("\n\t@LABEL%d:\n", rightLab) ;
	loadArrBase (rhs, "RDI") ;
	codePrint ("\t\tMOV[RBP%s], RDI", getOffsetStr(lhs->offset)) ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
orb $0x10, 0x159be(%rip)    # 0x17368
movl 0x159ab(%rip), %r15d    # 0x1735c
leal 0x1(%r15), %r12d
addl $0x2, %r15d
movl %r15d, 0x1599c(%rip)    # 0x1735c
leaq 0xd985(%rip), %rsi      # 0xf34c
callq 0x1603
leaq 0xe143(%rip), %rsi      # 0xfb16
movq %r14, %rdi
callq 0x1603
leaq 0x15966(%rip), %r13     # 0x17348
movq (%r13), %rcx
leaq 0xd8c6(%rip), %rdi      # 0xf2b3
movl $0xd, %esi
movl $0x1, %edx
callq 0x1170
movq (%r13), %rdi
leaq 0xd8ba(%rip), %rsi      # 0xf2c1
movl %r12d, %edx
xorl %eax, %eax
callq 0x1100
movq (%r13), %rcx
leaq 0xd8b4(%rip), %rdi      # 0xf2d0
movl $0x15, %esi
movl $0x1, %edx
callq 0x1170
movq (%r13), %rdi
leaq 0xd8b0(%rip), %rsi      # 0xf2e6
movl %r12d, %edx
xorl %eax, %eax
callq 0x1100
leaq 0xdd13(%rip), %rsi      # 0xf75a
movq %rbx, %rdi
callq 0x166c
leaq 0xd82c(%rip), %rsi      # 0xf282
movq %r14, %rdi
callq 0x166c
movq (%r13), %rcx
leaq 0xd88a(%rip), %rdi      # 0xf2f3
movl $0xd, %esi
movl $0x1, %edx
callq 0x1170
movq (%r13), %rdi
leaq 0xd83e(%rip), %rsi      # 0xf2c1
movl %r15d, %edx
xorl %eax, %eax
callq 0x1100
movq (%r13), %rcx
movl $0x15, %esi
movl $0x1, %edx
leaq 0xd82e(%rip), %rdi      # 0xf2d0
callq 0x1170
movq (%r13), %rdi
leaq 0xd834(%rip), %rsi      # 0xf2e6
movl %r15d, %edx
xorl %eax, %eax
callq 0x1100
leaq 0xd84c(%rip), %rsi      # 0xf30f
movq %r14, %rdi
callq 0x16d5
movq (%r13), %r14
movl 0x1c(%rbx), %edi
callq 0x1580
leaq 0xd823(%rip), %rsi      # 0xf301
leaq 0x1588b(%rip), %rdx     # 0x17370
movq %r14, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1100
// File: /workspace/github_c_makefile_star2_O3/anuwu[P]ERPLAG-Compiler/codegen.c
// Function: exprAssign
void exprAssign (astNode *node, moduleST *lst, int singleAssign)
{
	if (!singleAssign)
		codePrint ("\t\tPOP AX\n") ;

	if(node->child == NULL)
	{
		varST *searchedVar = searchVar (lst, node->tok->lexeme) ;
		if (node->next->id == TK_MINUS && node->next->child->next == NULL)
			codePrint ("\t\tNEG AX\n") ;

		codePrint ("\t\tMOV [RBP%s], AX", getOffsetStr (searchedVar->offset)) ;
	}
	else
	{
		varST* vst ;
		vst = searchVar (lst,node->tok->lexeme);

		if (isVarStaticArr(vst) && node->child->id == TK_NUM)
		{
			if (node->next->id == TK_MINUS && node->next->child->next == NULL)
				codePrint ("\t\tNEG AX\n") ;

			codePrint ("\t\tMOV [RBP%s], AX" , getOffsetStr(getStaticOffset(vst,node,2))) ;
		}
		else
		{
			if (node->next->id == TK_MINUS && node->next->child->next == NULL)
				codePrint ("\t\tNEG AX\n") ;

			arrBoundCheck (node, lst, vst) ;
			codePrint ("\t\tMOV [RDI + RBX], AX") ;
		}
	}
	codeComment (10, "store variable") ;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %r14
testl %edx, %edx
jne 0x1b32
leaq 0x1582f(%rip), %rax     # 0x17348
movq (%rax), %rcx
leaq 0xd7f0(%rip), %rdi      # 0xf313
movl $0x9, %esi
movl $0x1, %edx
callq 0x1170
movq 0x30(%r14), %r12
movq 0x8(%r14), %rax
movq 0x8(%rax), %rsi
movq %r15, %rdi
callq 0xb8e8
movq %rax, %rbx
testq %r12, %r12
je 0x1c36
movq %rbx, %rdi
callq 0xe01a
testl %eax, %eax
je 0x1bd2
movq 0x30(%r14), %rax
cmpl $0x71, (%rax)
jne 0x1bd2
movq 0x38(%r14), %rax
cmpl $0x58, (%rax)
jne 0x1b9b
movq 0x30(%rax), %rax
cmpq $0x0, 0x38(%rax)
jne 0x1b9b
leaq 0x157c6(%rip), %rax     # 0x17348
movq (%rax), %rcx
leaq 0xd791(%rip), %rdi      # 0xf31d
movl $0x9, %esi
movl $0x1, %edx
callq 0x1170
leaq 0x157a6(%rip), %rax     # 0x17348
movq (%rax), %r15
movq %rbx, %rdi
movq %r14, %rsi
movl $0x2, %edx
callq 0x176c
movl %eax, %edi
callq 0x1580
leaq 0xd764(%rip), %rsi      # 0xf327
leaq 0x157a6(%rip), %rdx     # 0x17370
movq %r15, %rdi
jmp 0x1c8d
movq 0x38(%r14), %rax
cmpl $0x58, (%rax)
jne 0x1c06
movq 0x30(%rax), %rax
cmpq $0x0, 0x38(%rax)
jne 0x1c06
leaq 0x1575b(%rip), %rax     # 0x17348
movq (%rax), %rcx
leaq 0xd726(%rip), %rdi      # 0xf31d
movl $0x9, %esi
movl $0x1, %edx
callq 0x1170
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x17b7
leaq 0x1572d(%rip), %rax     # 0x17348
movq (%rax), %rcx
leaq 0xd714(%rip), %rdi      # 0xf339
movl $0x15, %esi
movl $0x1, %edx
callq 0x1170
jmp 0x1c94
movq 0x38(%r14), %rax
cmpl $0x58, (%rax)
jne 0x1c6a
movq 0x30(%rax), %rax
cmpq $0x0, 0x38(%rax)
jne 0x1c6a
leaq 0x156f7(%rip), %rax     # 0x17348
movq (%rax), %rcx
leaq 0xd6c2(%rip), %rdi      # 0xf31d
movl $0x9, %esi
movl $0x1, %edx
callq 0x1170
leaq 0x156d7(%rip), %rax     # 0x17348
movq (%rax), %r14
movl 0x1c(%rbx), %edi
callq 0x1580
leaq 0xd6a4(%rip), %rsi      # 0xf327
leaq 0x156e6(%rip), %rdx     # 0x17370
movq %r14, %rdi
xorl %eax, %eax
callq 0x1100
leaq 0xd6b4(%rip), %rsi      # 0xf34f
movl $0xa, %edi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x152e
// File: /workspace/github_c_makefile_star2_O3/anuwu[P]ERPLAG-Compiler/codegen.c
// Function: RSPAlign
void RSPAlign ()
{
	codePrint ("\t\tMOV RAX, RSP") ;
	codeComment (9, "Stack Alignment") ;
	codePrint ("\t\tAND RAX, 15\n") ;
	codePrint ("\t\tADD RAX, 8\n") ;
	codePrint ("\t\tSUB RSP, RAX\n") ;
	codePrint ("\t\tPUSH RAX\n") ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x14f7c(%rip), %rbx     # 0x17348
movq (%rbx), %rcx
leaq 0xd177(%rip), %rdi      # 0xf54d
movl $0xe, %esi
movl $0x1, %edx
callq 0x1170
leaq 0xd1ce(%rip), %rsi      # 0xf5ba
movl $0x9, %edi
callq 0x152e
movq (%rbx), %rcx
leaq 0xd15c(%rip), %rdi      # 0xf55c
movl $0xe, %esi
movl $0x1, %edx
callq 0x1170
movq (%rbx), %rcx
leaq 0xd152(%rip), %rdi      # 0xf56b
movl $0xd, %esi
movl $0x1, %edx
callq 0x1170
movq (%rbx), %rcx
leaq 0xd147(%rip), %rdi      # 0xf579
movl $0xf, %esi
movl $0x1, %edx
callq 0x1170
movq (%rbx), %rcx
leaq 0xd13e(%rip), %rdi      # 0xf589
movl $0xb, %esi
movl $0x1, %edx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1170
// File: /workspace/github_c_makefile_star2_O3/anuwu[P]ERPLAG-Compiler/codegen.c
// Function: dynamicDeclarationCheck
void dynamicDeclarationCheck (moduleST *lst, varST *vst)
{
	int start_label , end_label ;
	varST *leftVar , *rightVar ;
	tf |= 1 << dynamicDeclCheck ;

	codePrint ("\n") ;
	if (isLeftLimStatic (vst))
		codePrint ("\t\tMOV AX, %s\n", vst->arrayIndices->tokLeft->lexeme) ;
	else
	{
		leftVar = searchVar (lst, vst->arrayIndices->tokLeft->lexeme) ;
		codePrint ("\t\tMOV AX, [RBP%s]\n", getOffsetStr (leftVar->offset)) ;
	}

	if (isRightLimStatic (vst))
		codePrint ("\t\tMOV BX, %s\n", vst->arrayIndices->tokRight->lexeme) ;
	else
	{
		rightVar = searchVar (lst, vst->arrayIndices->tokRight->lexeme) ;
		codePrint ("\t\tMOV BX, [RBP%s]\n", getOffsetStr(rightVar->offset)) ;
	}

	codePrint ("\t\tCALL @dynamicDeclCheck") ;
	codeComment (10, "checking dynamic array declaration limits") ;

	codePrint ("\n\n") ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
orb $0x40, 0x14cc1(%rip)    # 0x17369
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x14c93(%rip), %r12     # 0x17348
movq (%r12), %rsi
movl $0xa, %edi
callq 0x10e0
movq %r14, %rdi
callq 0xdfb8
testl %eax, %eax
je 0x26e8
movq (%r12), %rdi
movq 0x10(%r14), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdx
leaq 0xcfe8(%rip), %rsi      # 0xf6ce
jmp 0x2719
movq 0x10(%r14), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0xb8e8
movq (%r12), %r15
movl 0x1c(%rax), %edi
callq 0x1580
leaq 0xcfcd(%rip), %rsi      # 0xf6dc
leaq 0x14c5a(%rip), %rdx     # 0x17370
movq %r15, %rdi
xorl %eax, %eax
callq 0x1100
movq %r14, %rdi
callq 0xdfe9
testl %eax, %eax
je 0x2745
movq (%r12), %rdi
movq 0x10(%r14), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rdx
leaq 0xcfac(%rip), %rsi      # 0xf6ef
jmp 0x2776
movq 0x10(%r14), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0xb8e8
movq (%r12), %rbx
movl 0x1c(%rax), %edi
callq 0x1580
leaq 0xcf91(%rip), %rsi      # 0xf6fd
leaq 0x14bfd(%rip), %rdx     # 0x17370
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1100
movq (%r12), %rcx
leaq 0xcf88(%rip), %rdi      # 0xf710
movl $0x18, %esi
movl $0x1, %edx
callq 0x1170
leaq 0xcf8b(%rip), %rsi      # 0xf729
movl $0xa, %edi
callq 0x152e
movq (%r12), %rcx
leaq 0xd4d7(%rip), %rdi      # 0xfc8a
movl $0x2, %esi
movl $0x1, %edx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x1170
// File: /workspace/github_c_makefile_star2_O3/anuwu[P]ERPLAG-Compiler/codegen.c
// Function: getCaseCount
int getCaseCount (astNode *statementsNode)
{
	int cnt = 0 ;

	while (statementsNode != NULL)
	{
		cnt++ ;

		if (statementsNode->next != NULL)
		{
			if (statementsNode->next->id == TK_DEFAULT)
				return cnt ;

			statementsNode = statementsNode->next->next->next ;
		}
		else
			statementsNode = NULL ;
	}

	return cnt ;
}

// Assembly:
testq %rdi, %rdi
je 0x2bfe
pushq %rbp
movq %rsp, %rbp
movl $0x1, %ecx
movl %ecx, %eax
movq 0x38(%rdi), %rcx
testq %rcx, %rcx
je 0x2bfc
cmpl $0x55, (%rcx)
je 0x2bfc
movq 0x38(%rcx), %rcx
movq 0x38(%rcx), %rdi
leal 0x1(%rax), %ecx
testq %rdi, %rdi
jne 0x2bdc
popq %rbp
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/anuwu[P]ERPLAG-Compiler/codegen.c
// Function: switchDeclareVars
void switchDeclareVars (astNode *statementsNode)
{
	astNode *statementNode ;

	// Reserving space for switch scope variables
	while (statementsNode != NULL)
	{
		statementNode = statementsNode->child ;
		while (statementNode != NULL)
		{
			if (statementNode->child->id == TK_DECLARE)
			{
				moduleGeneration (statementNode->child, statementsNode->localST) ;
				statementNode->child->parent = statementNode->child ;		// tieing a knot
			}
			statementNode = statementNode->next ;
		}

		if (statementsNode->next != NULL)
		{
			if (statementsNode->next->id == TK_DEFAULT)
			{
				statementsNode = statementsNode->next->next ;
				statementNode = statementsNode->child ;
				while (statementNode != NULL)
				{
					if (statementNode->child->id == TK_DECLARE)
					{
						moduleGeneration (statementNode->child, statementsNode->localST) ;
						statementNode->child->parent = statementNode->child ;		// tieing a knot
					}
					statementNode = statementNode->next ;
				}

				break ;
			}
			statementsNode = statementsNode->next->next->next ;
		}
		else
			statementsNode = NULL ;
	}
}

// Assembly:
testq %rdi, %rdi
je 0x2c58
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0x30(%rbx), %r14
testq %r14, %r14
je 0x2c39
movq 0x30(%r14), %rdi
cmpl $0x3e, (%rdi)
jne 0x2c33
movq 0x20(%rbx), %rsi
callq 0x2c82
movq 0x30(%r14), %rax
movq %rax, 0x28(%rax)
movq 0x38(%r14), %r14
jmp 0x2c14
movq 0x38(%rbx), %rax
testq %rax, %rax
je 0x2c54
cmpl $0x55, (%rax)
movq 0x38(%rax), %rbx
je 0x2c59
movq 0x38(%rbx), %rbx
testq %rbx, %rbx
jne 0x2c10
popq %rbx
popq %r14
popq %rbp
retq
movq 0x30(%rbx), %r14
testq %r14, %r14
je 0x2c54
movq 0x30(%r14), %rdi
cmpl $0x3e, (%rdi)
jne 0x2c7c
movq 0x20(%rbx), %rsi
callq 0x2c82
movq 0x30(%r14), %rax
movq %rax, 0x28(%rax)
movq 0x38(%r14), %r14
jmp 0x2c5d
// File: /workspace/github_c_makefile_star2_O3/anuwu[P]ERPLAG-Compiler/codegen.c
// Function: pushInputDynamicArr
void pushInputDynamicArr (varST *vst, varSTentry *varEntry, char *reg, pushArrLim flag)
{
	int lab, sub ;

	if (flag == LEFT)
		sub = 10 ;
	else
		sub = 8 ;

	codePrint ("\t\tMOV %s, [RBP%s]\n", reg, getOffsetStr(vst->offset - sub)) ;

	if (isLeftLimStatic(varEntry->thisVarST) && !isLeftLimStatic(vst))
	{
		lab = get_label (LABEL_OTHER) ;
		tf |= 1 << argLimERROR ;

		if (flag == LEFT)
			codePrint ("\t\tMOV CX, %s\n", varEntry->thisVarST->arrayIndices->tokLeft->lexeme) ;
		else
			codePrint ("\t\tMOV CX, %s\n", varEntry->thisVarST->arrayIndices->tokRight->lexeme) ;

		codePrint ("\t\tCMP %s, CX\n", reg) ;
		codePrint ("\t\tJE @LABEL%d\n", lab) ;
		codePrint ("\t\tCALL @argLimERROR\n") ;
		codePrint ("\n\t@LABEL%d:\n", lab) ; 
	}

	if (!isVarStaticArr (varEntry->thisVarST))
		codePrint ("\t\tPUSH %s\n", reg) ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r15d
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
xorl %eax, %eax
testl %ecx, %ecx
setne %al
leaq 0x13aa0(%rip), %rcx     # 0x17348
movq (%rcx), %r13
movl 0x1c(%rdi), %ecx
leal (%rcx,%rax,2), %edi
addl $-0xa, %edi
callq 0x1580
leaq 0xc17c(%rip), %rsi      # 0xfa3c
leaq 0x13aa9(%rip), %rcx     # 0x17370
movq %r13, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1100
movq (%r14), %rdi
callq 0xdfb8
testl %eax, %eax
je 0x3996
movq %r12, %rdi
callq 0xdfb8
testl %eax, %eax
jne 0x3996
xorl %eax, %eax
testl %r15d, %r15d
setne %al
movl 0x13a59(%rip), %r15d    # 0x1735c
incl %r15d
movl %r15d, 0x13a4f(%rip)    # 0x1735c
orb $0x8, 0x13a54(%rip)     # 0x17368
leaq 0x13a2d(%rip), %r12     # 0x17348
movq (%r12), %rdi
movq (%r14), %rcx
movq 0x10(%rcx), %rcx
movq 0x8(%rcx,%rax,8), %rax
movq 0x8(%rax), %rdx
leaq 0xb92b(%rip), %rsi      # 0xf261
xorl %eax, %eax
callq 0x1100
movq (%r12), %rdi
leaq 0xc077(%rip), %rsi      # 0xf9bf
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1100
movq (%r12), %rdi
leaq 0xb964(%rip), %rsi      # 0xf2c1
movl %r15d, %edx
xorl %eax, %eax
callq 0x1100
movq (%r12), %rcx
leaq 0xc05b(%rip), %rdi      # 0xf9cd
movl $0x14, %esi
movl $0x1, %edx
callq 0x1170
movq (%r12), %rdi
leaq 0xb95a(%rip), %rsi      # 0xf2e6
movl %r15d, %edx
xorl %eax, %eax
callq 0x1100
movq (%r14), %rdi
callq 0xe01a
testl %eax, %eax
je 0x39b1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x13990(%rip), %rax     # 0x17348
movq (%rax), %rdi
leaq 0xb9c1(%rip), %rsi      # 0xf383
movq %rbx, %rdx
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1100
// File: /workspace/github_c_makefile_star2_O3/anuwu[P]ERPLAG-Compiler/codegen.c
// Function: pushInput
void pushInput (astNode *inputEnd, varSTentry *varEntry, moduleST *lst)
{
	varST *searchedVar ;

	while (varEntry->thisVarST->varType == VAR_PLACEHOLDER)
		varEntry = varEntry->next ;

	while (inputEnd != NULL)
	{
		searchedVar = searchVar (lst, inputEnd->tok->lexeme) ;

		if (searchedVar->datatype == TK_INTEGER || searchedVar->datatype == TK_BOOLEAN)
		{
			codePrint ("\t\tMOV AX, [RBP%s]\n", getOffsetStr(searchedVar->offset)) ;
			codePrint ("\t\tPUSH AX\n") ;
		}
		else if (isVarStaticArr (searchedVar))
		{
			loadArrBase (searchedVar, "RAX") ;
			codePrint ("\t\tPUSH RAX\n") ;
		}
		else
		{
			pushInputDynamicArr (searchedVar, varEntry, "AX", LEFT) ;
			pushInputDynamicArr (searchedVar, varEntry, "BX", RIGHT) ;
			loadArrBase (searchedVar, "RAX") ;
			codePrint ("\t\tPUSH RAX\n") ;
		}

		inputEnd = inputEnd->prev ;
		varEntry = varEntry->next ;
		while (varEntry != NULL && varEntry->thisVarST->varType == VAR_PLACEHOLDER)
			varEntry = varEntry->next ;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, -0x30(%rbp)
movq %rsi, %r14
movq %rdi, %r15
movq (%rsi), %rax
cmpl $0x1, 0x30(%rax)
jne 0x3ae6
movq 0x8(%r14), %r14
movq (%r14), %rax
jmp 0x39f5
movq 0x8(%r15), %rax
movq 0x8(%rax), %rsi
movq -0x30(%rbp), %rdi
callq 0xb8e8
movq %rax, %r13
movl 0x8(%rax), %eax
cmpl $0x39, %eax
je 0x3a29
cmpl $0x37, %eax
jne 0x3a6a
leaq 0x13918(%rip), %rbx     # 0x17348
movq (%rbx), %r12
movl 0x1c(%r13), %edi
callq 0x1580
movq %r12, %rdi
leaq 0xbc96(%rip), %rsi      # 0xf6dc
leaq 0x13923(%rip), %rdx     # 0x17370
xorl %eax, %eax
callq 0x1100
movq (%rbx), %rcx
movl $0xa, %esi
movl $0x1, %edx
leaq 0xba2a(%rip), %rdi      # 0xf492
jmp 0x3acb
movq %r13, %rdi
callq 0xe01a
testl %eax, %eax
jne 0x3aa1
movq %r13, %rdi
movq %r14, %rsi
leaq 0xb8c9(%rip), %rdx      # 0xf34c
xorl %ecx, %ecx
callq 0x3880
movq %r13, %rdi
movq %r14, %rsi
leaq 0xbcc3(%rip), %rdx      # 0xf75a
movl $0x1, %ecx
callq 0x3880
movq %r13, %rdi
leaq 0xbb01(%rip), %rsi      # 0xf5ac
callq 0x16d5
leaq 0x13891(%rip), %rax     # 0x17348
movq (%rax), %rcx
movl $0xb, %esi
movl $0x1, %edx
leaq 0xbabe(%rip), %rdi      # 0xf589
callq 0x1170
movq 0x40(%r15), %r15
movq 0x8(%r14), %r14
testq %r14, %r14
je 0x3ae6
movq (%r14), %rax
cmpl $0x1, 0x30(%rax)
je 0x3ad4
testq %r15, %r15
jne 0x3a08
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/anuwu[P]ERPLAG-Compiler/codegen.c
// Function: popOutput
void popOutput (astNode *outputHead, moduleST *lst)
{
	varST* searchedVar ;

	while (outputHead != NULL)
	{
		searchedVar = searchVar (lst, outputHead->tok->lexeme) ;
		codePrint ("\t\tPOP AX\n") ;
		codePrint ("\t\tMOV [RBP%s], AX\n", getOffsetStr(searchedVar->offset)) ;

		outputHead = outputHead->next ;
	}

	codePrint ("\n") ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x3b79
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x1382a(%rip), %r13     # 0x17348
movq 0x8(%r14), %rax
movq 0x8(%rax), %rsi
movq %rbx, %rdi
callq 0xb8e8
movq %rax, %r15
movq (%r13), %rcx
movl $0x9, %esi
movl $0x1, %edx
leaq 0xb7cd(%rip), %rdi      # 0xf313
callq 0x1170
movq (%r13), %r12
movl 0x1c(%r15), %edi
callq 0x1580
movq %r12, %rdi
leaq 0xbe80(%rip), %rsi      # 0xf9e2
leaq 0x13807(%rip), %rdx     # 0x17370
xorl %eax, %eax
callq 0x1100
movq 0x38(%r14), %r14
testq %r14, %r14
jne 0x3b1e
leaq 0x137c8(%rip), %rax     # 0x17348
movq (%rax), %rsi
movl $0xa, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x10e0
// File: /workspace/github_c_makefile_star2_O3/anuwu[P]ERPLAG-Compiler/codegen.c
// Function: retModule
void retModule (moduleST *lst)
{
	codePrint ("\n\t\tMOV RSP, RBP\n") ;
	codePrint ("\t\tPOP RBP\n") ;

	if (lst == realBase->driverST)		// driver module
	{
		#ifdef __linux__
			codePrint ("\t\tMOV RAX, 60\n") ;
			codePrint ("\t\tXOR RDI, RDI\n") ;
			codePrint ("\t\tsyscall\n") ;
		#endif
			
		#ifdef __MACH__
			codePrint ("\t\tMOV RAX, 0x2000001\n") ;
			codePrint ("\t\tXOR RDI, RDI\n") ;
			codePrint ("\t\tsyscall\n") ;
		#endif

		#ifdef _WIN64
			codePrint ("\t\tret\n") ;
		#endif
	}
	else
		codePrint ("\t\tret\n") ;

	printCommentLineNASM () ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x1379c(%rip), %r14     # 0x17348
movq (%r14), %rcx
leaq 0xbe3f(%rip), %rdi      # 0xf9f5
movl $0x10, %esi
movl $0x1, %edx
callq 0x1170
movq (%r14), %rcx
leaq 0xbe37(%rip), %rdi      # 0xfa06
movl $0xa, %esi
movl $0x1, %edx
callq 0x1170
leaq 0x2d443(%rip), %rax     # 0x31028
movq (%rax), %rax
movq (%r14), %rcx
cmpq %rbx, 0xd0(%rax)
je 0x3c02
leaq 0xc211(%rip), %rdi      # 0xfe0c
movl $0x6, %esi
jmp 0x3c40
leaq 0xbe08(%rip), %rdi      # 0xfa11
movl $0xe, %esi
movl $0x1, %edx
callq 0x1170
movq (%r14), %rcx
leaq 0xbdfe(%rip), %rdi      # 0xfa20
movl $0xf, %esi
movl $0x1, %edx
callq 0x1170
movq (%r14), %rcx
leaq 0xbdf5(%rip), %rdi      # 0xfa30
movl $0xa, %esi
movl $0x1, %edx
callq 0x1170
movq (%r14), %rcx
leaq 0xcd90(%rip), %rdi      # 0x109e4
movl $0x65, %esi
movl $0x1, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x1170
// File: /workspace/github_c_makefile_star2_O3/anuwu[P]ERPLAG-Compiler/codegen.c
// Function: freeDynamic
void freeDynamic (varSTentry *varEntry)
{
	if (varEntry == NULL)
		return ;

	char freeReg[5] ;
	RSPAlign () ;

	#if defined __linux__ || defined __MACH__
		strcpy (freeReg, "RDI") ;
	#endif
	#ifdef _WIN64
		strcpy (freeReg, "RCX") ;
		codePrint ("\n\t\tSUB RSP, 32\n") ;
	#endif

	while (varEntry != NULL)
	{
		codePrint ("\n\t\tMOV %s, [RBP%s]\n", freeReg, getOffsetStr (varEntry->thisVarST->offset)) ;

		#if defined __linux__ || defined _WIN64
			codePrint ("\t\tCALL free") ;
		#endif
		#ifdef __MACH__ 
			codePrint ("\t\tCALL _free") ;
		#endif
		codeComment (8, "freeing local dynamic arrays\n") ;

		varEntry = varEntry->next ;
	}

	#ifdef _WIN64
		codePrint ("\t\tADD RSP, 32\n") ;
	#endif

	RSPRestore () ;
}

// Assembly:
testq %rdi, %rdi
je 0x3d0f
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x23bf
leaq -0x30(%rbp), %rax
movl $0x494452, (%rax)       # imm = 0x494452
leaq 0x136b1(%rip), %r12     # 0x17348
leaq 0xbdb1(%rip), %r13      # 0xfa4f
leaq 0xbdb6(%rip), %r14      # 0xfa5b
movq (%r12), %r15
movq (%rbx), %rax
movl 0x1c(%rax), %edi
callq 0x1580
movq %r15, %rdi
leaq 0xbd7d(%rip), %rsi      # 0xfa3b
leaq -0x30(%rbp), %rdx
leaq 0x136a7(%rip), %rcx     # 0x17370
xorl %eax, %eax
callq 0x1100
movq (%r12), %rcx
movl $0xb, %esi
movl $0x1, %edx
movq %r13, %rdi
callq 0x1170
movl $0x8, %edi
movq %r14, %rsi
callq 0x152e
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
jne 0x3ca5
callq 0x2460
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/anuwu[P]ERPLAG-Compiler/codegen.c
// Function: codeGeneration
void codeGeneration(astNode *node)
{
	if (node == NULL)
		return;

	switch (node->id)
	{
		case program :
			codeGeneration (node->child->next) ;		// <otherModules>
			break ;

		case otherModules :
			codeGeneration (node->child) ;					// Do module definitions
			codeGeneration (node->next) ;					// <driverModule> or NULL
			break ;

		case module :
			codePrint ("\n%s:\n", strcmp(node->child->tok->lexeme , "main") ? node->child->tok->lexeme : "@main") ;
			codePrint ("\t\tPUSH RBP\n") ;
			codePrint ("\t\tMOV RBP, RSP\n\n") ;

			moduleGeneration (node->child->next->next->next, NULL) ;
			codeGeneration (node->next) ;					// Moving on to the next module

			break ;

		case driverModule :
			#ifdef __linux__
				codePrint ("\nmain:\n") ;
			#endif

			#ifdef __MACH__
				codePrint ("\n_main:\n") ;
			#endif

			#ifdef _WIN64
				codePrint ("\nWinMain:\n") ;
			#endif

			codePrint ("\t\tPUSH RBP\n") ;
			codePrint ("\t\tMOV RBP, RSP\n\n") ;

			moduleGeneration(node->child, NULL); 				// <statements>
			codeGeneration(node->next); 				// Move to the next child of program

			break ;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x3e5f
movq %rdi, %rbx
leaq 0xb4cb(%rip), %r12      # 0xf1fc
leaq 0x13610(%rip), %r15     # 0x17348
leaq 0xbef3(%rip), %r14      # 0xfc32
leaq 0xbef8(%rip), %r13      # 0xfc3e
movl (%rbx), %eax
cmpq $0x9, %rax
ja 0x3e5f
movslq (%r12,%rax,4), %rax
addq %r12, %rax
jmpq *%rax
movq 0x30(%rbx), %rbx
jmp 0x3e52
movq 0x30(%rbx), %rdi
callq 0x3d10
jmp 0x3e52
movq (%r15), %rcx
movl $0x7, %esi
movl $0x1, %edx
leaq 0xbec9(%rip), %rdi      # 0xfc4f
callq 0x1170
movq (%r15), %rcx
movl $0xb, %esi
movl $0x1, %edx
movq %r14, %rdi
callq 0x1170
movq (%r15), %rcx
movl $0x10, %esi
movl $0x1, %edx
movq %r13, %rdi
callq 0x1170
movq 0x30(%rbx), %rdi
jmp 0x3e4b
movq (%r15), %r12
movq 0x30(%rbx), %rax
movq 0x8(%rax), %rax
movq %r14, %r13
movq 0x8(%rax), %r14
movq %r14, %rdi
leaq 0xbe37(%rip), %rsi      # 0xfc11
callq 0x10f0
testl %eax, %eax
leaq 0xbe28(%rip), %rax      # 0xfc10
cmoveq %rax, %r14
movq %r12, %rdi
leaq 0xb406(%rip), %r12      # 0xf1fc
leaq 0xbe2f(%rip), %rsi      # 0xfc2c
movq %r14, %rdx
movq %r13, %r14
leaq 0xbe34(%rip), %r13      # 0xfc3e
xorl %eax, %eax
callq 0x1100
movq (%r15), %rcx
movl $0xb, %esi
movl $0x1, %edx
movq %r14, %rdi
callq 0x1170
movq (%r15), %rcx
movl $0x10, %esi
movl $0x1, %edx
movq %r13, %rdi
callq 0x1170
movq 0x30(%rbx), %rax
movq 0x38(%rax), %rax
movq 0x38(%rax), %rax
movq 0x38(%rax), %rdi
xorl %esi, %esi
callq 0x2c82
movq 0x38(%rbx), %rbx
testq %rbx, %rbx
jne 0x3d46
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/anuwu[P]ERPLAG-Compiler/codegen.c
// Function: preamble
void preamble()
{
	codePrint (";;;;;;;;;;; Compiled for 64-bit ") ;

	#ifdef __linux__
		codePrint ("Linux ") ;
	#endif
	#ifdef __MACH__
		codePrint ("macOS ") ;
	#endif
	#ifdef _WIN64
		codePrint ("Windows ") ;
	#endif

	codePrint (";;;;;;;;;;;\n\n") ;

	#if defined __linux__ || defined _WIN64
		codePrint ("extern printf\n") ;
		codePrint ("extern scanf\n") ;
		codePrint ("extern malloc\n") ;
		codePrint ("extern free\n") ;
		codePrint ("extern exit\n") ;

		#ifdef __linux__
			codePrint ("\nglobal main\n") ;
		#endif

		#ifdef _WIN64
			codePrint ("\nglobal WinMain\n") ;
		#endif
	#endif

	#ifdef __MACH__
		codePrint ("extern _printf\n") ;
		codePrint ("extern _scanf\n") ;
		codePrint ("extern _malloc\n") ;
		codePrint ("extern _free\n") ;
		codePrint ("extern _exit\n") ;

		codePrint ("\nglobal _main\n") ;
	#endif

	codePrint ("section .text\n") ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x134cd(%rip), %rbx     # 0x17348
movq (%rbx), %rcx
leaq 0xbdd2(%rip), %rdi      # 0xfc57
movl $0x20, %esi
movl $0x1, %edx
callq 0x1170
movq (%rbx), %rcx
leaq 0xbdda(%rip), %rdi      # 0xfc78
movl $0x6, %esi
movl $0x1, %edx
callq 0x1170
movq (%rbx), %rcx
leaq 0xbdc8(%rip), %rdi      # 0xfc7f
movl $0xd, %esi
movl $0x1, %edx
callq 0x1170
movq (%rbx), %rcx
leaq 0xbdbd(%rip), %rdi      # 0xfc8d
movl $0xe, %esi
movl $0x1, %edx
callq 0x1170
movq (%rbx), %rcx
leaq 0xbdb3(%rip), %rdi      # 0xfc9c
movl $0xd, %esi
movl $0x1, %edx
callq 0x1170
movq (%rbx), %rcx
leaq 0xbda8(%rip), %rdi      # 0xfcaa
movl $0xe, %esi
movl $0x1, %edx
callq 0x1170
movq (%rbx), %rcx
leaq 0xbd9e(%rip), %rdi      # 0xfcb9
movl $0xc, %esi
movl $0x1, %edx
callq 0x1170
movq (%rbx), %rcx
leaq 0xbd92(%rip), %rdi      # 0xfcc6
movl $0xc, %esi
movl $0x1, %edx
callq 0x1170
movq (%rbx), %rcx
leaq 0xbd86(%rip), %rdi      # 0xfcd3
movl $0xd, %esi
movl $0x1, %edx
callq 0x1170
movq (%rbx), %rcx
leaq 0xbd7b(%rip), %rdi      # 0xfce1
movl $0xe, %esi
movl $0x1, %edx
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x1170
// File: /workspace/github_c_makefile_star2_O3/anuwu[P]ERPLAG-Compiler/codegen.c
// Function: errorTF
void errorTF (char *errStr)
{
	RSPAlign () ;

	#if defined __linux__ || defined __MACH__
		codePrint ("\t\tMOV RDI, %s\n", errStr) ;
		codePrint ("\t\tXOR RSI, RSI\n") ;
		codePrint ("\t\tXOR RAX, RAX\n") ;
	#endif
	#ifdef _WIN64
		codePrint ("\t\tMOV RCX, %s\n", errStr) ;
		codePrint ("\t\tXOR RDX, RDX\n") ;
		codePrint ("\t\tSUB RSP, 32\n") ;
	#endif

	#if defined __linux__ || defined _WIN64
		codePrint ("\t\tCALL printf\n") ;
		#ifdef _WIN64
			codePrint ("\t\tADD RSP, 32\n") ;
		#endif
	#endif
	#ifdef __MACH__
		codePrint ("\t\tCALL _printf\n") ;
	#endif

	#if defined __linux__ || defined __MACH__
		codePrint ("\t\tMOV RDI, 1\n") ;
	#endif
	#ifdef _WIN64
		codePrint ("\t\tMOV RCX, 1\n") ;
	#endif

	#if defined __linux__ || defined _WIN64
		codePrint ("\t\tCALL exit\n") ;
	#endif
	#ifdef __MACH__
		codePrint ("\t\tCALL _exit\n") ;
	#endif
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
callq 0x23bf
leaq 0x133a9(%rip), %r14     # 0x17348
movq (%r14), %rdi
leaq 0xbd47(%rip), %rsi      # 0xfcf0
movq %rbx, %rdx
xorl %eax, %eax
callq 0x1100
movq (%r14), %rcx
leaq 0xbd42(%rip), %rdi      # 0xfcff
movl $0xf, %esi
movl $0x1, %edx
callq 0x1170
movq (%r14), %rcx
leaq 0xbd39(%rip), %rdi      # 0xfd0f
movl $0xf, %esi
movl $0x1, %edx
callq 0x1170
movq (%r14), %rcx
leaq 0xbd30(%rip), %rdi      # 0xfd1f
movl $0xe, %esi
movl $0x1, %edx
callq 0x1170
movq (%r14), %rcx
leaq 0xbd26(%rip), %rdi      # 0xfd2e
movl $0xd, %esi
movl $0x1, %edx
callq 0x1170
movq (%r14), %rcx
leaq 0xbd1b(%rip), %rdi      # 0xfd3c
movl $0xc, %esi
movl $0x1, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x1170
// File: /workspace/github_c_makefile_star2_O3/anuwu[P]ERPLAG-Compiler/codegen.c
// Function: printArrStart
void printArrStart ()
{
	codePrint ("\t\tPUSH RDI\n") ;

	#if defined __linux__ || defined __MACH__
		codePrint ("\t\tMOV RDI, @printFormatArray\n") ;
		codePrint ("\t\tXOR RSI, RSI\n") ;
		codePrint ("\t\tXOR RAX, RAX\n") ;
		codePrint ("\t\tPUSH AX\n") ;
		codePrint ("\t\tPUSH BX\n") ;
		codePrint ("\t\tPUSH CX\n") ;
		codePrint ("\t\tPUSH DX\n") ;
	#endif
	#ifdef _WIN64
		codePrint ("\t\tMOV RCX, @printFormatArray\n") ;
		codePrint ("\t\tXOR RDX, RDX\n") ;
		codePrint ("\t\tPUSH BX\n") ;
		codePrint ("\t\tSUB RSP, 38\n") ;
	#endif

	#if defined __linux__ || defined _WIN64
		codePrint ("\t\tCALL printf\n") ;
		#ifdef _WIN64
			codePrint ("\t\tADD RSP, 38\n") ;
		#endif
	#endif
	#ifdef __MACH__
		codePrint ("\t\tCALL _printf\n") ;
	#endif

	#if defined __linux__ || defined __MACH__
		codePrint ("\t\tPOP DX\n") ;
		codePrint ("\t\tPOP CX\n") ;
		codePrint ("\t\tPOP BX\n") ;
		codePrint ("\t\tPOP AX\n") ;
		codePrint ("\t\tPOP RDI\n\n") ;
		codePrint ("\t\tMOV CX, 0\n") ;
	#endif
	#ifdef _WIN64
		codePrint ("\t\tPOP BX\n") ;
		codePrint ("\t\tPOP RDI\n\n") ;
		codePrint ("\t\tMOV AX, 0\n") ;
	#endif

	codePrint ("\n\t.printArr:") ;
	codeComment (8, "printing array") ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
leaq 0x13307(%rip), %rbx     # 0x17348
movq (%rbx), %rcx
leaq 0xc15c(%rip), %rdi      # 0x101a7
movl $0xb, %esi
movl $0x1, %edx
callq 0x1170
movq (%rbx), %rcx
leaq 0xbce5(%rip), %rdi      # 0xfd49
movl $0x1d, %esi
movl $0x1, %edx
callq 0x1170
movq (%rbx), %rcx
leaq 0xbc82(%rip), %rdi      # 0xfcff
movl $0xf, %esi
movl $0x1, %edx
callq 0x1170
movq (%rbx), %rcx
leaq 0xbc79(%rip), %rdi      # 0xfd0f
movl $0xf, %esi
movl $0x1, %edx
callq 0x1170
movq (%rbx), %rcx
leaq 0xb3e3(%rip), %rdi      # 0xf492
movl $0xa, %esi
movl $0x1, %edx
callq 0x1170
movq (%rbx), %rcx
leaq 0xbc9f(%rip), %rdi      # 0xfd67
movl $0xa, %esi
movl $0x1, %edx
callq 0x1170
movq (%rbx), %rcx
leaq 0xbc91(%rip), %rdi      # 0xfd72
movl $0xa, %esi
movl $0x1, %edx
callq 0x1170
movq (%rbx), %rcx
leaq 0xbc83(%rip), %rdi      # 0xfd7d
movl $0xa, %esi
movl $0x1, %edx
callq 0x1170
movq (%rbx), %rcx
leaq 0xbc0c(%rip), %rdi      # 0xfd1f
movl $0xe, %esi
movl $0x1, %edx
callq 0x1170
movq (%rbx), %rcx
leaq 0xbc5c(%rip), %rdi      # 0xfd88
movl $0x9, %esi
movl $0x1, %edx
callq 0x1170
movq (%rbx), %rcx
leaq 0xbc4d(%rip), %rdi      # 0xfd92
movl $0x9, %esi
movl $0x1, %edx
callq 0x1170
movq (%rbx), %rcx
leaq 0xb230(%rip), %rdi      # 0xf38e
movl $0x9, %esi
movl $0x1, %edx
callq 0x1170
movq (%rbx), %rcx
leaq 0xb19c(%rip), %rdi      # 0xf313
movl $0x9, %esi
movl $0x1, %edx
callq 0x1170
movq (%rbx), %rcx
leaq 0xbc0c(%rip), %rdi      # 0xfd9c
movl $0xb, %esi
movl $0x1, %edx
callq 0x1170
movq (%rbx), %rcx
leaq 0xbbff(%rip), %rdi      # 0xfda8
movl $0xc, %esi
movl $0x1, %edx
callq 0x1170
movq (%rbx), %rcx
leaq 0xbbf3(%rip), %rdi      # 0xfdb5
movl $0xc, %esi
movl $0x1, %edx
callq 0x1170
leaq 0xbbea(%rip), %rsi      # 0xfdc2
movl $0x8, %edi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x152e
// File: /workspace/github_c_makefile_star2_O3/anuwu[P]ERPLAG-Compiler/codegen.c
// Function: printArrEnd
void printArrEnd ()
{
	#if defined __linux__ || defined _WIN64
		codePrint ("\t\tCALL printf\n") ;
		#ifdef _WIN64
			codePrint ("\t\tADD RSP, 36\n") ;
		#endif
	#endif
	#ifdef __MACH__
		codePrint ("\t\tCALL _printf\n") ;
	#endif

	#if defined __linux__ || defined __MACH__
		codePrint ("\t\tPOP DX\n") ;
		codePrint ("\t\tPOP CX\n") ;
		codePrint ("\t\tPOP BX\n") ;
		codePrint ("\t\tPOP AX\n") ;
		codePrint ("\t\tPOP RDI\n\n") ;
		codePrint ("\t\tADD CX, 2\n") ;
		codePrint ("\t\tCMP CX, DX\n") ;
	#endif
	#ifdef _WIN64
		codePrint ("\t\tPOP BX\n") ;
		codePrint ("\t\tPOP AX\n") ;
		codePrint ("\t\tPOP RDI\n\n") ;
		codePrint ("\t\tADD AX, 2\n") ;
		codePrint ("\t\tCMP AX, BX\n") ;
	#endif

	codePrint ("\t\tJNE .printArr\n\n") ;

	#if defined __linux__ || defined __MACH__
		codePrint ("\t\tMOV RDI, @printNewLine\n") ;
		codePrint ("\t\tXOR RSI, RSI\n") ;
		codePrint ("\t\tXOR RAX, RAX\n") ;
	#endif
	#ifdef _WIN64
		codePrint ("\t\tMOV RCX, @printNewLine\n") ;
		codePrint ("\t\tXOR RDX, RDX\n") ;
		codePrint ("\t\tSUB RSP, 32\n") ;
	#endif

	#if defined __linux__ || defined _WIN64
		codePrint ("\t\tCALL printf\n") ;
		#ifdef _WIN64
			codePrint ("\t\tADD RSP, 32\n") ;
		#endif
	#endif
	#ifdef __MACH__
		codePrint ("\t\tCALL _printf\n") ;
	#endif

	RSPRestore () ;
	codePrint ("\n\t\tret\n") ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
leaq 0x13152(%rip), %r14     # 0x17348
movq (%r14), %rcx
leaq 0xbb1f(%rip), %rbx      # 0xfd1f
movl $0xe, %esi
movl $0x1, %edx
movq %rbx, %rdi
callq 0x1170
movq (%r14), %rcx
leaq 0xbb6c(%rip), %rdi      # 0xfd88
movl $0x9, %esi
movl $0x1, %edx
callq 0x1170
movq (%r14), %rcx
leaq 0xbb5d(%rip), %rdi      # 0xfd92
movl $0x9, %esi
movl $0x1, %edx
callq 0x1170
movq (%r14), %rcx
leaq 0xb140(%rip), %rdi      # 0xf38e
movl $0x9, %esi
movl $0x1, %edx
callq 0x1170
movq (%r14), %rcx
leaq 0xb0ac(%rip), %rdi      # 0xf313
movl $0x9, %esi
movl $0x1, %edx
callq 0x1170
movq (%r14), %rcx
leaq 0xbb1c(%rip), %rdi      # 0xfd9c
movl $0xb, %esi
movl $0x1, %edx
callq 0x1170
movq (%r14), %rcx
leaq 0xc1b3(%rip), %rdi      # 0x1044c
movl $0xc, %esi
movl $0x1, %edx
callq 0x1170
movq (%r14), %rcx
leaq 0xbb1f(%rip), %rdi      # 0xfdd1
movl $0xd, %esi
movl $0x1, %edx
callq 0x1170
movq (%r14), %rcx
leaq 0xbb14(%rip), %rdi      # 0xfddf
movl $0x11, %esi
movl $0x1, %edx
callq 0x1170
movq (%r14), %rcx
leaq 0xbb0d(%rip), %rdi      # 0xfdf1
movl $0x19, %esi
movl $0x1, %edx
callq 0x1170
movq (%r14), %rcx
leaq 0xba02(%rip), %rdi      # 0xfcff
movl $0xf, %esi
movl $0x1, %edx
callq 0x1170
movq (%r14), %rcx
leaq 0xb9f9(%rip), %rdi      # 0xfd0f
movl $0xf, %esi
movl $0x1, %edx
callq 0x1170
movq (%r14), %rcx
movl $0xe, %esi
movl $0x1, %edx
movq %rbx, %rdi
callq 0x1170
callq 0x2460
movq (%r14), %rcx
leaq 0xbac2(%rip), %rdi      # 0xfe0b
movl $0x7, %esi
movl $0x1, %edx
popq %rbx
popq %r14
popq %rbp
jmp 0x1170
// File: /workspace/github_c_makefile_star2_O3/anuwu[P]ERPLAG-Compiler/ast.c
// Function: connectChildren
void connectChildren (astNode *parent, astNode **siblings, int num)
{
	for (int i = 0 ; i < num - 1; i++)
	{
		siblings[i]->next = siblings[i+1] ;
		siblings[i]->parent = parent ;
	}

	siblings[num-1]->parent = parent ;
	for (int i = num-1 ; i > 0 ; i--)
		siblings[i]->prev = siblings[i-1] ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
leal -0x1(%rdx), %ecx
cmpl $0x1, %edx
jle 0x5f14
movl %ecx, %eax
xorl %r8d, %r8d
movq (%rsi,%r8,8), %r9
movq 0x8(%rsi,%r8,8), %r10
movq %r10, 0x38(%r9)
movq (%rsi,%r8,8), %r9
leaq 0x1(%r8), %r10
movq %rdi, 0x28(%r9)
movq %r10, %r8
cmpq %r10, %rax
jne 0x5ec7
movslq %ecx, %rcx
movq (%rsi,%rcx,8), %rcx
movq %rdi, 0x28(%rcx)
cmpl $0x2, %edx
jl 0x5f1f
incq %rax
movq -0x10(%rsi,%rax,8), %rcx
movq -0x8(%rsi,%rax,8), %rdx
movq %rcx, 0x40(%rdx)
decq %rax
cmpq $0x1, %rax
ja 0x5efb
jmp 0x5f1f
movslq %ecx, %rax
movq (%rsi,%rax,8), %rax
movq %rdi, 0x28(%rax)
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/anuwu[P]ERPLAG-Compiler/lexer.c
// Function: getLexemeLineNumber
int getLexemeLineNumber (twinBuffer *twinBuf)
{
	int line = twinBuf->lineNumber ;
 
	if (twinBuf->forward == twinBuf->buf1)
		return line ;
 
	if ((twinBuf->forward == twinBuf->buf2 && twinBuf->buf1[bufSize - 1] == '\n') || (*(twinBuf->forward - 1) == '\n') && *twinBuf->forward != EOF)
		return line - 1 ;
}

// Assembly:
movl 0x30(%rdi), %eax
movq 0x8(%rdi), %rdx
movq 0x20(%rdi), %rcx
cmpq %rdx, %rcx
je 0x745d
pushq %rbp
movq %rsp, %rbp
cmpq 0x10(%rdi), %rcx
jne 0x744d
cmpb $0xa, 0x7f(%rdx)
je 0x7458
cmpb $0xa, -0x1(%rcx)
jne 0x745c
cmpb $-0x1, (%rcx)
je 0x745c
decl %eax
jmp 0x745c
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/anuwu[P]ERPLAG-Compiler/lexer.c
// Function: retract
void retract (twinBuffer *twinBuf)
{
	if (twinBuf->where_forward == TWIN_ONE)
	{
		if (twinBuf->forward == twinBuf->buf1)
			printf ("Cannot retract!\n") ;
		else
			twinBuf->forward-- ;
	}
	else if (twinBuf->where_forward == TWIN_TWO)
	{
		if (twinBuf->forward == twinBuf->buf2)
		{
			twinBuf->forward = &twinBuf->buf1[bufSize - 1] ;
			twinBuf->where_forward = TWIN_ONE ;
		}
		else
			twinBuf->forward-- ;
	}
 
	if (*twinBuf->forward == '\n')
		twinBuf->lineNumber-- ;
 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x2c(%rdi), %eax
cmpl $0x1, %eax
je 0x76e6
testl %eax, %eax
jne 0x770c
movq 0x20(%rbx), %rax
cmpq 0x8(%rbx), %rax
jne 0x76f0
leaq 0x9897(%rip), %rdi      # 0x10f76
callq 0x1070
jmp 0x770c
movq 0x20(%rbx), %rax
cmpq 0x10(%rbx), %rax
je 0x76f9
decq %rax
movq %rax, 0x20(%rbx)
jmp 0x770c
movq 0x8(%rbx), %rax
addq $0x7f, %rax
movq %rax, 0x20(%rbx)
movl $0x0, 0x2c(%rbx)
movq 0x20(%rbx), %rax
cmpb $0xa, (%rax)
jne 0x7718
decl 0x30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/anuwu[P]ERPLAG-Compiler/parser.c
// Function: populate_hash
void populate_hash(int index,int enum_value)
{
	if(heads[enum_value].ind == -1)
	{
		heads[enum_value].ind=index;	
	}

	else
	{
		location* tmp=&heads[enum_value];
		while(tmp->next!=NULL)
		{
			tmp=tmp->next;
		}
		tmp->next=init();
		tmp=tmp->next;
		tmp->ind=index;
		tmp->next=NULL;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %edi, %ebx
movslq %esi, %rcx
shlq $0x4, %rcx
leaq 0xeb8d(%rip), %rdx      # 0x17380
leaq (%rdx,%rcx), %rax
cmpl $-0x1, (%rcx,%rdx)
je 0x8823
movq %rax, %r14
movq 0x8(%rax), %rax
testq %rax, %rax
jne 0x87fd
movl $0x10, %edi
callq 0x1120
movq %rax, 0x8(%r14)
movl %ebx, (%rax)
movq $0x0, 0x8(%rax)
jmp 0x8825
movl %ebx, (%rax)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/anuwu[P]ERPLAG-Compiler/parser.c
// Function: traverse_grammar
void traverse_grammar()
{
	for(int i=0;i<150;i++)
	{
		for(int j=0;j<150;j++)
		{
			parsetable[i][j]=-1;
		}
	}	

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


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

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

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

				temp2=temp2->next;
			}

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

		}

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
leaq 0xf6b8(%rip), %rbx      # 0x19770
movl $0x15f90, %edx          # imm = 0x15F90
movq %rbx, %rdi
movl $0xff, %esi
callq 0x10c0
movslq 0x2562f(%rip), %rax     # 0x2f700
testq %rax, %rax
jle 0xa198
xorl %ecx, %ecx
leaq 0x2562d(%rip), %rdx     # 0x2f710
leaq 0x262a6(%rip), %rsi     # 0x30390
leaq 0x268df(%rip), %rdi     # 0x309d0
movq %rcx, %r8
shlq $0x4, %r8
movslq (%r8,%rdx), %r9
movq 0x8(%r8,%rdx), %r10
cmpl $0x36, (%r10)
jne 0xa134
movq (%rsi,%r9,8), %r8
testq %r8, %r8
je 0xa12a
imulq $0x258, %r9, %r9        # imm = 0x258
addq %rbx, %r9
movl (%r8), %r10d
movl %ecx, (%r9,%r10,4)
movq 0x8(%r8), %r8
testq %r8, %r8
jne 0xa11a
incq %rcx
cmpq %rax, %rcx
jne 0xa0f1
jmp 0xa198
imulq $0x258, %r9, %r8        # imm = 0x258
addq %rbx, %r8
movl (%r10), %r11d
movq (%rdi,%r11,8), %r11
testq %r11, %r11
je 0xa12a
movb $0x1, %r14b
movl (%r11), %r15d
cmpq $0x36, %r15
je 0xa165
movl %ecx, (%r8,%r15,4)
movq 0x8(%r11), %r11
testq %r11, %r11
jne 0xa14d
jmp 0xa173
movq 0x8(%r11), %r11
xorl %r14d, %r14d
testq %r11, %r11
jne 0xa14d
jmp 0xa179
testb $0x1, %r14b
jne 0xa12a
movq 0x8(%r10), %r10
testq %r10, %r10
jne 0xa13e
movq (%rsi,%r9,8), %r9
testq %r9, %r9
je 0xa12a
movl (%r9), %r10d
movl %ecx, (%r8,%r10,4)
movq 0x8(%r9), %r9
jmp 0xa186
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/anuwu[P]ERPLAG-Compiler/parser.c
// Function: addUniquely
void addUniquely(tokenID target, tokenID insert_it)
{
	//Target linked list should never be empty
	node * tmp_target = firsts[target];

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

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

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

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

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

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

	if(sourceLL == NULL)
		return;

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

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

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

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

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

			sourceLL = sourceLL->next;
		}
	}

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %eax
leaq 0x26782(%rip), %r15     # 0x309d0
movq (%r15,%rax,8), %r14
testq %r14, %r14
je 0xa2d3
movl %edi, %ebx
movl %edi, %r12d
cmpq $0x0, (%r15,%r12,8)
je 0xa27d
movl (%r14), %esi
cmpl $0x36, %esi
je 0xa272
movl %ebx, %edi
callq 0xa1a3
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0xa263
jmp 0xa2d3
movl (%r14), %r13d
movl $0x10, %edi
callq 0x1120
movl %r13d, (%rax)
movq $0x0, 0x8(%rax)
movq %rax, (%r15,%r12,8)
movq 0x8(%r14), %r14
testq %r14, %r14
je 0xa2d3
movq %rax, %rbx
movl (%r14), %r15d
cmpl $0x36, %r15d
je 0xa2ca
movl $0x10, %edi
callq 0x1120
movl %r15d, (%rax)
movq $0x0, 0x8(%rax)
movq %rax, 0x8(%rbx)
movq %rax, %rbx
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0xa2a5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/anuwu[P]ERPLAG-Compiler/parser.c
// Function: containsEpsilon
int containsEpsilon(tokenID id)
{
	node* tmp = firsts[id];
	while(tmp){
		if(tmp->key == TK_EPS)
			return 1;
		tmp = tmp->next ;
	}
	return 0;
}

// Assembly:
movl %edi, %eax
leaq 0x266e5(%rip), %rcx     # 0x309d0
movq (%rcx,%rax,8), %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0xa310
pushq %rbp
movq %rsp, %rbp
cmpl $0x36, (%rcx)
je 0xa30a
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
jne 0xa2fa
jmp 0xa30f
movl $0x1, %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/anuwu[P]ERPLAG-Compiler/parser.c
// Function: populateFirst
void populateFirst (tokenID id)
{
	if(isTerminal(id))
		return;

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

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

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

			unionFirst (id, rRHS->key) ;

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

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

		ruleLoc = ruleLoc->next ;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edi, %ebx
leal -0x36(%rbx), %eax
cmpl $0x3d, %eax
jb 0xa3a8
movl %ebx, %eax
shlq $0x4, %rax
leaq 0xd04a(%rip), %r14      # 0x17380
addq %rax, %r14
leaq 0x253d0(%rip), %r15     # 0x2f710
leaq 0x26689(%rip), %r12     # 0x309d0
movslq (%r14), %rax
shlq $0x4, %rax
movq 0x8(%rax,%r15), %r13
testq %r13, %r13
je 0xa393
movl (%r13), %esi
cmpq $0x0, (%r12,%rsi,8)
jne 0xa36e
movl %esi, %edi
callq 0xa311
movl (%r13), %esi
movl %ebx, %edi
callq 0xa237
movl (%r13), %eax
movq (%r12,%rax,8), %rax
testq %rax, %rax
je 0xa39f
cmpl $0x36, (%rax)
je 0xa38d
movq 0x8(%rax), %rax
jmp 0xa37d
movq 0x8(%r13), %r13
jmp 0xa353
movl %ebx, %edi
movl $0x36, %esi
callq 0xa1a3
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0xa347
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq