LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/anuwu[P]ERPLAG-Compiler/codegen.c
// Function: codeComment
void codeComment (int tabCount, char *comment)
{
	int i ;
	for (i = 0 ; i < tabCount ; i++)
		codePrint ("\t") ;

	codePrint ("; %s\n", comment) ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x1701
leaq 0x1bc43(%rip), %rax     # 0x1d328
movq (%rax), %rdi
leaq 0x13ca9(%rip), %rsi     # 0x15398
movb $0x0, %al
callq 0x10d0
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x16d6
leaq 0x1bc20(%rip), %rax     # 0x1d328
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x13c84(%rip), %rsi     # 0x1539a
movb $0x0, %al
callq 0x10d0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/anuwu[P]ERPLAG-Compiler/codegen.c
// Function: getOffsetStr
char* getOffsetStr (int offset)
{	
	if (offset > 0)
		sprintf (offsetStr, " - %d", offset) ;
	else if (offset < 0)
		sprintf (offsetStr, " + %d", -offset) ;
	else
		memset (offsetStr, 0, 10) ;

	return offsetStr ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
cmpl $0x0, -0x4(%rbp)
jle 0x175b
movl -0x4(%rbp), %edx
leaq 0x1bc05(%rip), %rdi     # 0x1d350
leaq 0x13c4e(%rip), %rsi     # 0x153a0
movb $0x0, %al
callq 0x1120
jmp 0x1792
cmpl $0x0, -0x4(%rbp)
jge 0x177d
xorl %edx, %edx
subl -0x4(%rbp), %edx
leaq 0x1bbe3(%rip), %rdi     # 0x1d350
leaq 0x13c32(%rip), %rsi     # 0x153a6
movb $0x0, %al
callq 0x1120
jmp 0x1790
leaq 0x1bbcc(%rip), %rdi     # 0x1d350
xorl %esi, %esi
movl $0xa, %edx
callq 0x10a0
jmp 0x1792
leaq 0x1bbb7(%rip), %rax     # 0x1d350
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/anuwu[P]ERPLAG-Compiler/codegen.c
// Function: loadArrBase
void loadArrBase (varST *vst, char *reg)
{
	if (isVarStaticArr (vst))
	{
		if (vst->varType == VAR_LOCAL)
		{
			codePrint ("\t\tMOV %s, RBP\n", reg) ;
			codePrint ("\t\tSUB %s, %d\n", reg, vst->offset) ;			
		}
		else
			codePrint ("\t\tMOV %s, [RBP%s]\n", reg, getOffsetStr (vst->offset)) ;
	}
	else
		codePrint ("\t\tMOV %s, [RBP%s]\n", reg, getOffsetStr(vst->offset)) ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0x13fc0
cmpl $0x0, %eax
je 0x19aa
movq -0x8(%rbp), %rax
cmpl $0x3, 0x30(%rax)
jne 0x196d
leaq 0x1b9f5(%rip), %rax     # 0x1d328
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
leaq 0x13a79(%rip), %rsi     # 0x153ba
movb $0x0, %al
callq 0x10d0
leaq 0x1b9d9(%rip), %rax     # 0x1d328
movq (%rax), %rdi
movq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %ecx
leaq 0x13a65(%rip), %rsi     # 0x153c9
movb $0x0, %al
callq 0x10d0
jmp 0x19a8
leaq 0x1b9b4(%rip), %rax     # 0x1d328
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %edi
callq 0x1730
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq %rax, %rcx
leaq 0x14211(%rip), %rsi     # 0x15bb2
movb $0x0, %al
callq 0x10d0
jmp 0x19e5
leaq 0x1b977(%rip), %rax     # 0x1d328
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %edi
callq 0x1730
movq -0x30(%rbp), %rdi
movq -0x28(%rbp), %rdx
movq %rax, %rcx
leaq 0x141d4(%rip), %rsi     # 0x15bb2
movb $0x0, %al
callq 0x10d0
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq $0x0, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x17a0
cmpl $0x0, %eax
jne 0x1aa7
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x10ba0
movq %rax, -0x20(%rbp)
movl 0x1b89b(%rip), %eax     # 0x1d348
orl $0x2000, %eax           # imm = 0x2000
movl %eax, 0x1b890(%rip)     # 0x1d348
movq -0x18(%rbp), %rdi
leaq 0x139c2(%rip), %rsi     # 0x15485
callq 0x1900
movq -0x18(%rbp), %rdi
leaq 0x13dfd(%rip), %rsi     # 0x158d0
callq 0x17e0
cmpq $0x0, -0x20(%rbp)
jne 0x1b09
leaq 0x1b842(%rip), %rax     # 0x1d328
movq (%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdx
leaq 0x138d7(%rip), %rsi     # 0x153d7
movb $0x0, %al
callq 0x10d0
jmp 0x1b38
leaq 0x1b818(%rip), %rax     # 0x1d328
movq (%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movl 0x1c(%rax), %edi
callq 0x1730
movq -0x28(%rbp), %rdi
movq %rax, %rdx
leaq 0x138b4(%rip), %rsi     # 0x153e5
movb $0x0, %al
callq 0x10d0
movq -0x18(%rbp), %rdi
leaq 0x138b5(%rip), %rsi     # 0x153f8
callq 0x1870
leaq 0x1b7d9(%rip), %rax     # 0x1d328
movq (%rax), %rdi
leaq 0x138a2(%rip), %rsi     # 0x153fb
movb $0x0, %al
callq 0x10d0
movl $0xa, %edi
leaq 0x138a2(%rip), %rsi     # 0x1540e
callq 0x16c0
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/anuwu[P]ERPLAG-Compiler/codegen.c
// Function: isExprLeaf
int isExprLeaf (tokenID id)
{
	switch (id)
	{
		case TK_ID :
			return 1 ;
		case TK_NUM :
			return 1 ;
		case TK_TRUE :
			return 1 ;
		case TK_FALSE :
			return 1 ;

		default :
			return 0 ;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, -0xc(%rbp)
subl $0x40, %eax
je 0x1bb2
jmp 0x1b94
movl -0xc(%rbp), %eax
subl $0x48, %eax
je 0x1bc4
jmp 0x1b9e
movl -0xc(%rbp), %eax
subl $0x49, %eax
je 0x1bcd
jmp 0x1ba8
movl -0xc(%rbp), %eax
subl $0x71, %eax
je 0x1bbb
jmp 0x1bd6
movl $0x1, -0x4(%rbp)
jmp 0x1bdd
movl $0x1, -0x4(%rbp)
jmp 0x1bdd
movl $0x1, -0x4(%rbp)
jmp 0x1bdd
movl $0x1, -0x4(%rbp)
jmp 0x1bdd
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x38(%rax), %rax
cmpl $0x40, (%rax)
jne 0x1cea
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x38(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x10ba0
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpl $0x3b, 0x8(%rax)
jne 0x1ce8
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq 0x38(%rax), %rax
cmpq $0x0, 0x30(%rax)
jne 0x1ce8
movl $0x1, -0x4(%rbp)
jmp 0x1cf1
jmp 0x1cea
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl 0x1b602(%rip), %eax     # 0x1d348
orl $0x10, %eax
movl %eax, 0x1b5f9(%rip)     # 0x1d348
movl $0x4, %edi
callq 0x1600
movl %eax, -0x14(%rbp)
movl $0x4, %edi
callq 0x1600
movl %eax, -0x18(%rbp)
movq -0x8(%rbp), %rdi
leaq 0x1374e(%rip), %rsi     # 0x154c2
callq 0x17e0
movq -0x10(%rbp), %rdi
leaq 0x13f08(%rip), %rsi     # 0x15c8c
callq 0x17e0
leaq 0x1b598(%rip), %rax     # 0x1d328
movq (%rax), %rdi
leaq 0x1368f(%rip), %rsi     # 0x15429
movb $0x0, %al
callq 0x10d0
leaq 0x1b580(%rip), %rax     # 0x1d328
movq (%rax), %rdi
movl -0x14(%rbp), %edx
leaq 0x13682(%rip), %rsi     # 0x15437
movb $0x0, %al
callq 0x10d0
leaq 0x1b565(%rip), %rax     # 0x1d328
movq (%rax), %rdi
leaq 0x13679(%rip), %rsi     # 0x15446
movb $0x0, %al
callq 0x10d0
leaq 0x1b54d(%rip), %rax     # 0x1d328
movq (%rax), %rdi
movl -0x14(%rbp), %edx
leaq 0x13674(%rip), %rsi     # 0x1545c
movb $0x0, %al
callq 0x10d0
movq -0x8(%rbp), %rdi
leaq 0x13ad6(%rip), %rsi     # 0x158d0
callq 0x1870
movq -0x10(%rbp), %rdi
leaq 0x135ee(%rip), %rsi     # 0x153f8
callq 0x1870
leaq 0x1b512(%rip), %rax     # 0x1d328
movq (%rax), %rdi
leaq 0x13649(%rip), %rsi     # 0x15469
movb $0x0, %al
callq 0x10d0
leaq 0x1b4fa(%rip), %rax     # 0x1d328
movq (%rax), %rdi
movl -0x18(%rbp), %edx
leaq 0x135fc(%rip), %rsi     # 0x15437
movb $0x0, %al
callq 0x10d0
leaq 0x1b4df(%rip), %rax     # 0x1d328
movq (%rax), %rdi
leaq 0x135f3(%rip), %rsi     # 0x15446
movb $0x0, %al
callq 0x10d0
leaq 0x1b4c7(%rip), %rax     # 0x1d328
movq (%rax), %rdi
movl -0x18(%rbp), %edx
leaq 0x135ee(%rip), %rsi     # 0x1545c
movb $0x0, %al
callq 0x10d0
movq -0x10(%rbp), %rdi
leaq 0x13605(%rip), %rsi     # 0x15485
callq 0x1900
leaq 0x1b49c(%rip), %rax     # 0x1d328
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %edi
callq 0x1730
movq -0x20(%rbp), %rdi
movq %rax, %rdx
leaq 0x135ca(%rip), %rsi     # 0x15477
movb $0x0, %al
callq 0x10d0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
leaq 0x1a8fd(%rip), %rax     # 0x1d328
movq (%rax), %rdi
leaq 0x12c8e(%rip), %rsi     # 0x156c3
movb $0x0, %al
callq 0x10d0
movl $0x9, %edi
leaq 0x12ce8(%rip), %rsi     # 0x15730
callq 0x16c0
leaq 0x1a8d4(%rip), %rax     # 0x1d328
movq (%rax), %rdi
leaq 0x12c74(%rip), %rsi     # 0x156d2
movb $0x0, %al
callq 0x10d0
leaq 0x1a8bc(%rip), %rax     # 0x1d328
movq (%rax), %rdi
leaq 0x12c6b(%rip), %rsi     # 0x156e1
movb $0x0, %al
callq 0x10d0
leaq 0x1a8a4(%rip), %rax     # 0x1d328
movq (%rax), %rdi
leaq 0x12c61(%rip), %rsi     # 0x156ef
movb $0x0, %al
callq 0x10d0
leaq 0x1a88c(%rip), %rax     # 0x1d328
movq (%rax), %rdi
leaq 0x12c59(%rip), %rsi     # 0x156ff
movb $0x0, %al
callq 0x10d0
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl 0x1a5b2(%rip), %eax     # 0x1d348
orl $0x4000, %eax           # imm = 0x4000
movl %eax, 0x1a5a7(%rip)     # 0x1d348
leaq 0x1a580(%rip), %rax     # 0x1d328
movq (%rax), %rdi
leaq 0x1304f(%rip), %rsi     # 0x15e01
movb $0x0, %al
callq 0x10d0
movq -0x10(%rbp), %rdi
callq 0x13f40
cmpl $0x0, %eax
je 0x2df1
leaq 0x1a55a(%rip), %rax     # 0x1d328
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdx
leaq 0x12a5c(%rip), %rsi     # 0x15844
movb $0x0, %al
callq 0x10d0
jmp 0x2e3d
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x10ba0
movq %rax, -0x20(%rbp)
leaq 0x1a513(%rip), %rax     # 0x1d328
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movl 0x1c(%rax), %edi
callq 0x1730
movq -0x30(%rbp), %rdi
movq %rax, %rdx
leaq 0x12a1c(%rip), %rsi     # 0x15852
movb $0x0, %al
callq 0x10d0
movq -0x10(%rbp), %rdi
callq 0x13f80
cmpl $0x0, %eax
je 0x2e75
leaq 0x1a4d6(%rip), %rax     # 0x1d328
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rdx
leaq 0x129f9(%rip), %rsi     # 0x15865
movb $0x0, %al
callq 0x10d0
jmp 0x2ec1
movq -0x8(%rbp), %rdi
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x10ba0
movq %rax, -0x28(%rbp)
leaq 0x1a48f(%rip), %rax     # 0x1d328
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x28(%rbp), %rax
movl 0x1c(%rax), %edi
callq 0x1730
movq -0x38(%rbp), %rdi
movq %rax, %rdx
leaq 0x129b9(%rip), %rsi     # 0x15873
movb $0x0, %al
callq 0x10d0
leaq 0x1a460(%rip), %rax     # 0x1d328
movq (%rax), %rdi
leaq 0x129b4(%rip), %rsi     # 0x15886
movb $0x0, %al
callq 0x10d0
movl $0xa, %edi
leaq 0x129ba(%rip), %rsi     # 0x1589f
callq 0x16c0
leaq 0x1a437(%rip), %rax     # 0x1d328
movq (%rax), %rdi
leaq 0x12f05(%rip), %rsi     # 0x15e00
movb $0x0, %al
callq 0x10d0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl $0x0, -0x14(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x33bf
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x33b5
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
cmpl $0x55, (%rax)
jne 0x339f
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x33c5
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x38(%rax), %rax
movq 0x38(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x33bd
movq $0x0, -0x10(%rbp)
jmp 0x336f
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x34e6
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x343e
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
cmpl $0x3e, (%rax)
jne 0x3430
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x34f0
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x33f3
movq -0x8(%rbp), %rax
cmpq $0x0, 0x38(%rax)
je 0x34d9
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
cmpl $0x55, (%rax)
jne 0x34c3
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x38(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x30(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0x34c1
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
cmpl $0x3e, (%rax)
jne 0x34b3
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rdi
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rsi
callq 0x34f0
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rcx
movq -0x10(%rbp), %rax
movq 0x30(%rax), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0x3476
jmp 0x34e6
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq 0x38(%rax), %rax
movq 0x38(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x34e1
movq $0x0, -0x8(%rbp)
jmp 0x33dc
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jne 0x4456
movl $0xa, -0x24(%rbp)
jmp 0x445d
movl $0x8, -0x24(%rbp)
leaq 0x18ec4(%rip), %rax     # 0x1d328
movq (%rax), %rax
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rax
movl 0x1c(%rax), %edi
subl -0x24(%rbp), %edi
callq 0x1730
movq -0x38(%rbp), %rdi
movq -0x30(%rbp), %rdx
movq %rax, %rcx
leaq 0x1171e(%rip), %rsi     # 0x15bb2
movb $0x0, %al
callq 0x10d0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x13f40
cmpl $0x0, %eax
je 0x45a6
movq -0x8(%rbp), %rdi
callq 0x13f40
cmpl $0x0, %eax
jne 0x45a6
movl $0x4, %edi
callq 0x1600
movl %eax, -0x20(%rbp)
movl 0x18e73(%rip), %eax     # 0x1d348
orl $0x8, %eax
movl %eax, 0x18e6a(%rip)     # 0x1d348
cmpl $0x0, -0x1c(%rbp)
jne 0x4511
leaq 0x18e3d(%rip), %rax     # 0x1d328
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdx
leaq 0x10ecf(%rip), %rsi     # 0x153d7
movb $0x0, %al
callq 0x10d0
jmp 0x453c
leaq 0x18e10(%rip), %rax     # 0x1d328
movq (%rax), %rdi
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rdx
leaq 0x10ea2(%rip), %rsi     # 0x153d7
movb $0x0, %al
callq 0x10d0
leaq 0x18de5(%rip), %rax     # 0x1d328
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
leaq 0x115e4(%rip), %rsi     # 0x15b35
movb $0x0, %al
callq 0x10d0
leaq 0x18dc9(%rip), %rax     # 0x1d328
movq (%rax), %rdi
movl -0x20(%rbp), %edx
leaq 0x10ecb(%rip), %rsi     # 0x15437
movb $0x0, %al
callq 0x10d0
leaq 0x18dae(%rip), %rax     # 0x1d328
movq (%rax), %rdi
leaq 0x115bf(%rip), %rsi     # 0x15b43
movb $0x0, %al
callq 0x10d0
leaq 0x18d96(%rip), %rax     # 0x1d328
movq (%rax), %rdi
movl -0x20(%rbp), %edx
leaq 0x10ebd(%rip), %rsi     # 0x1545c
movb $0x0, %al
callq 0x10d0
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x13fc0
cmpl $0x0, %eax
jne 0x45d3
leaq 0x18d6a(%rip), %rax     # 0x1d328
movq (%rax), %rdi
movq -0x18(%rbp), %rdx
leaq 0x10f2d(%rip), %rsi     # 0x154f9
movb $0x0, %al
callq 0x10d0
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
cmpq $0x0, -0x8(%rbp)
je 0x4805
movq -0x10(%rbp), %rdi
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x10ba0
movq %rax, -0x18(%rbp)
leaq 0x18b71(%rip), %rax     # 0x1d328
movq (%rax), %rdi
leaq 0x10cc8(%rip), %rsi     # 0x15489
movb $0x0, %al
callq 0x10d0
leaq 0x18b59(%rip), %rax     # 0x1d328
movq (%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movl 0x1c(%rax), %edi
callq 0x1730
movq -0x20(%rbp), %rdi
movq %rax, %rdx
leaq 0x11368(%rip), %rsi     # 0x15b58
movb $0x0, %al
callq 0x10d0
movq -0x8(%rbp), %rax
movq 0x38(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x4790
leaq 0x18b1c(%rip), %rax     # 0x1d328
movq (%rax), %rdi
leaq 0x115eb(%rip), %rsi     # 0x15e01
movb $0x0, %al
callq 0x10d0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
leaq 0x18ae5(%rip), %rax     # 0x1d328
movq (%rax), %rdi
leaq 0x1131e(%rip), %rsi     # 0x15b6b
movb $0x0, %al
callq 0x10d0
leaq 0x18acd(%rip), %rax     # 0x1d328
movq (%rax), %rdi
leaq 0x11317(%rip), %rsi     # 0x15b7c
movb $0x0, %al
callq 0x10d0
movq -0x8(%rbp), %rax
leaq 0x32791(%rip), %rcx     # 0x37008
movq (%rcx), %rcx
cmpq 0xd0(%rcx), %rax
jne 0x48cd
leaq 0x18a9e(%rip), %rax     # 0x1d328
movq (%rax), %rdi
leaq 0x112f3(%rip), %rsi     # 0x15b87
movb $0x0, %al
callq 0x10d0
leaq 0x18a86(%rip), %rax     # 0x1d328
movq (%rax), %rdi
leaq 0x112ea(%rip), %rsi     # 0x15b96
movb $0x0, %al
callq 0x10d0
leaq 0x18a6e(%rip), %rax     # 0x1d328
movq (%rax), %rdi
leaq 0x112e2(%rip), %rsi     # 0x15ba6
movb $0x0, %al
callq 0x10d0
jmp 0x48e5
leaq 0x18a54(%rip), %rax     # 0x1d328
movq (%rax), %rdi
leaq 0x116a4(%rip), %rsi     # 0x15f82
movb $0x0, %al
callq 0x10d0
callq 0x6b00
addq $0x10, %rsp
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
cmpq $0x0, -0x8(%rbp)
jne 0x4908
jmp 0x499e
callq 0x2a20
leaq -0xd(%rbp), %rdi
leaq 0x10b6d(%rip), %rsi     # 0x15485
callq 0x1040
cmpq $0x0, -0x8(%rbp)
je 0x4999
leaq 0x189fd(%rip), %rax     # 0x1d328
movq (%rax), %rax
movq %rax, -0x20(%rbp)
leaq -0xd(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq (%rax), %rax
movl 0x1c(%rax), %edi
callq 0x1730
movq -0x20(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq %rax, %rcx
leaq 0x11256(%rip), %rsi     # 0x15bb1
movb $0x0, %al
callq 0x10d0
leaq 0x189bf(%rip), %rax     # 0x1d328
movq (%rax), %rdi
leaq 0x11252(%rip), %rsi     # 0x15bc5
movb $0x0, %al
callq 0x10d0
movl $0x8, %edi
leaq 0x1124b(%rip), %rsi     # 0x15bd1
callq 0x16c0
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x8(%rbp)
jmp 0x491d
callq 0x2ab0
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
leaq 0x187bd(%rip), %rax     # 0x1d328
movq (%rax), %rdi
leaq 0x11258(%rip), %rsi     # 0x15dcd
movb $0x0, %al
callq 0x10d0
leaq 0x187a5(%rip), %rax     # 0x1d328
movq (%rax), %rdi
leaq 0x11261(%rip), %rsi     # 0x15dee
movb $0x0, %al
callq 0x10d0
leaq 0x1878d(%rip), %rax     # 0x1d328
movq (%rax), %rdi
leaq 0x11250(%rip), %rsi     # 0x15df5
movb $0x0, %al
callq 0x10d0
leaq 0x18775(%rip), %rax     # 0x1d328
movq (%rax), %rdi
leaq 0x11246(%rip), %rsi     # 0x15e03
movb $0x0, %al
callq 0x10d0
leaq 0x1875d(%rip), %rax     # 0x1d328
movq (%rax), %rdi
leaq 0x1123d(%rip), %rsi     # 0x15e12
movb $0x0, %al
callq 0x10d0
leaq 0x18745(%rip), %rax     # 0x1d328
movq (%rax), %rdi
leaq 0x11233(%rip), %rsi     # 0x15e20
movb $0x0, %al
callq 0x10d0
leaq 0x1872d(%rip), %rax     # 0x1d328
movq (%rax), %rdi
leaq 0x1122a(%rip), %rsi     # 0x15e2f
movb $0x0, %al
callq 0x10d0
leaq 0x18715(%rip), %rax     # 0x1d328
movq (%rax), %rdi
leaq 0x1121f(%rip), %rsi     # 0x15e3c
movb $0x0, %al
callq 0x10d0
leaq 0x186fd(%rip), %rax     # 0x1d328
movq (%rax), %rdi
leaq 0x11214(%rip), %rsi     # 0x15e49
movb $0x0, %al
callq 0x10d0
leaq 0x186e5(%rip), %rax     # 0x1d328
movq (%rax), %rdi
leaq 0x1120a(%rip), %rsi     # 0x15e57
movb $0x0, %al
callq 0x10d0
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
callq 0x2a20
leaq 0x18670(%rip), %rax     # 0x1d328
movq (%rax), %rdi
movq -0x8(%rbp), %rdx
leaq 0x111a0(%rip), %rsi     # 0x15e66
movb $0x0, %al
callq 0x10d0
leaq 0x18654(%rip), %rax     # 0x1d328
movq (%rax), %rdi
leaq 0x11197(%rip), %rsi     # 0x15e75
movb $0x0, %al
callq 0x10d0
leaq 0x1863c(%rip), %rax     # 0x1d328
movq (%rax), %rdi
leaq 0x1118f(%rip), %rsi     # 0x15e85
movb $0x0, %al
callq 0x10d0
leaq 0x18624(%rip), %rax     # 0x1d328
movq (%rax), %rdi
leaq 0x11187(%rip), %rsi     # 0x15e95
movb $0x0, %al
callq 0x10d0
leaq 0x1860c(%rip), %rax     # 0x1d328
movq (%rax), %rdi
leaq 0x1117e(%rip), %rsi     # 0x15ea4
movb $0x0, %al
callq 0x10d0
leaq 0x185f4(%rip), %rax     # 0x1d328
movq (%rax), %rdi
leaq 0x11174(%rip), %rsi     # 0x15eb2
movb $0x0, %al
callq 0x10d0
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/anuwu[P]ERPLAG-Compiler/ast.c
// Function: createASTNode
astNode* createASTNode (treeNode *PTNode)
{
	astNode *node = (astNode *) malloc (sizeof(astNode)) ;

 	if (PTNode->tag == NON_TERMINAL)
 	{
 		//printf ("\tcreateASTNODE : PTNode->tnt.nonTerm = %d\n", PTNode->tnt.nonTerm) ;
 		node->id = PTNode->tnt.nonTerm ;
 		//printf ("\tcreateASTNODE : node->id = %d\n", node->id) ;
 		node->tok = NULL ;
 	}
 	else
 	{
 		node->id = PTNode->tnt.term->id ;
 		node->tok = PTNode->tnt.term ;
 	}

 	node->parent = NULL ;
 	node->child = NULL ;
 	node->next = NULL ;
 	node->prev = NULL ;
 	node->dt = NULL ;
 	node->localST = NULL ;

 	PTNode->syn = node ;

 	return node ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movl $0x48, %edi
callq 0x10e0
movq %rax, -0x10(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x1, (%rax)
jne 0x6b5e
movq -0x8(%rbp), %rax
movl 0x8(%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
jmp 0x6b7e
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rax
movl (%rax), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x28(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x30(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x38(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x40(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x18(%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x20(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
movl -0x14(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x6e93
movq -0x10(%rbp), %rax
movl -0x18(%rbp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rcx
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rdx
movq (%rax,%rdx,8), %rax
movq %rcx, 0x38(%rax)
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movslq -0x18(%rbp), %rdx
movq (%rax,%rdx,8), %rax
movq %rcx, 0x28(%rax)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x6e46
movq -0x8(%rbp), %rcx
movq -0x10(%rbp), %rax
movl -0x14(%rbp), %edx
subl $0x1, %edx
movslq %edx, %rdx
movq (%rax,%rdx,8), %rax
movq %rcx, 0x28(%rax)
movl -0x14(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x1c(%rbp)
cmpl $0x0, -0x1c(%rbp)
jle 0x6ee7
movq -0x10(%rbp), %rax
movl -0x1c(%rbp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rcx
movq -0x10(%rbp), %rax
movslq -0x1c(%rbp), %rdx
movq (%rax,%rdx,8), %rax
movq %rcx, 0x40(%rax)
movl -0x1c(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x6eb5
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/anuwu[P]ERPLAG-Compiler/lexer.c
// Function: lexer_init
twinBuffer* lexer_init (FILE *fp)
{
	int buf1_read, buf2_read ;
	twinBuffer *twinBuf = (twinBuffer *) malloc (sizeof(twinBuffer)) ;
	twinBuf->fp = fp ;
 
	if (twinBuf->fp == NULL)
		return NULL ;
 
	twinBuf->buf1 = (char *) malloc (sizeof(char) * (bufSize + 1)) ;
	twinBuf->buf2 = (char *) malloc (sizeof(char) * (bufSize + 1)) ;
 
	buf1_read = fread (twinBuf->buf1, sizeof(char), bufSize, twinBuf->fp) ;
	twinBuf->buf1[buf1_read] = EOF ;
	twinBuf->begin = twinBuf->buf1 ;
	twinBuf->forward = twinBuf->buf1 ;
	twinBuf->where_begin = TWIN_ONE ;
	twinBuf->where_forward = TWIN_ONE ;
 
	buf2_read = fread (twinBuf->buf2, sizeof(char) , bufSize, twinBuf->fp) ;
	twinBuf->buf2[buf2_read] = EOF ;
 
	twinBuf->lineNumber = 1 ;
 
	return twinBuf ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movl $0x38, %edi
callq 0x10e0
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, (%rax)
movq -0x20(%rbp), %rax
cmpq $0x0, (%rax)
jne 0xa00c
movq $0x0, -0x8(%rbp)
jmp 0xa0e1
movl $0x81, %edi
callq 0x10e0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movl $0x81, %edi
callq 0x10e0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movl $0x1, %esi
movl $0x80, %edx
callq 0x1060
movl %eax, -0x14(%rbp)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movb $-0x1, (%rax,%rcx)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x28(%rax)
movq -0x20(%rbp), %rax
movl $0x0, 0x2c(%rax)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rdi
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movl $0x1, %esi
movl $0x80, %edx
callq 0x1060
movl %eax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movslq -0x18(%rbp), %rcx
movb $-0x1, (%rax,%rcx)
movq -0x20(%rbp), %rax
movl $0x1, 0x30(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rax
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/anuwu[P]ERPLAG-Compiler/lexer.c
// Function: lexer_destroy
void lexer_destroy (twinBuffer *twinBuf)
{
	free (twinBuf->buf1) ;
	free (twinBuf->buf2) ;
	fclose (twinBuf->fp) ;

	free (twinBuf) ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x1030
movq -0x8(%rbp), %rax
movq (%rax), %rdi
callq 0x1070
movq -0x8(%rbp), %rdi
callq 0x1030
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x30(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0xa16c
movl -0x14(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0xa1b9
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jne 0xa18f
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movsbl 0x7f(%rax), %eax
cmpl $0xa, %eax
je 0xa1b0
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movsbl -0x1(%rax), %eax
cmpl $0xa, %eax
jne 0xa1b9
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movsbl (%rax), %eax
cmpl $-0x1, %eax
je 0xa1b9
movl -0x14(%rbp), %eax
subl $0x1, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/anuwu[P]ERPLAG-Compiler/lexer.c
// Function: resetBeginPointer
void resetBeginPointer (twinBuffer *twinBuf)
{
	if (twinBuf->where_begin == twinBuf->where_forward)
		twinBuf->begin = twinBuf->forward ;
	else
	{
		twinBuf->begin = twinBuf->forward ;
		twinBuf->where_begin = TWIN_TWO ;
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0x28(%rax), %eax
movq -0x8(%rbp), %rcx
cmpl 0x2c(%rcx), %eax
jne 0xa1ea
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
jmp 0xa205
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movl $0x1, 0x28(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
cmpl $0x0, 0x2c(%rax)
jne 0xa48a
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x8(%rcx), %rax
jne 0xa478
leaq 0xcc26(%rip), %rdi      # 0x17095
movb $0x0, %al
callq 0x1090
jmp 0xa488
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x20(%rax)
jmp 0xa4db
movq -0x8(%rbp), %rax
cmpl $0x1, 0x2c(%rax)
jne 0xa4d9
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq -0x8(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jne 0xa4c7
movq -0x8(%rbp), %rax
movq 0x8(%rax), %rcx
addq $0x7f, %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x8(%rbp), %rax
movl $0x0, 0x2c(%rax)
jmp 0xa4d7
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
addq $-0x1, %rcx
movq %rcx, 0x20(%rax)
jmp 0xa4d9
jmp 0xa4db
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0xa4f8
movq -0x8(%rbp), %rax
movl 0x30(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x30(%rax)
addq $0x10, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/anuwu[P]ERPLAG-Compiler/lexer.c
// Function: getNextToken
token* getNextToken(twinBuffer *twinBuf)
{
	token *  toret = getNextTok(twinBuf);
	while(1){
		if(toret->id !=TK_COMMENT)
			return toret;
 
		toret = getNextTok(twinBuf);
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
callq 0xa6c0
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpl $0x4b, (%rax)
je 0xa6ac
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
movq -0x8(%rbp), %rdi
callq 0xa6c0
movq %rax, -0x10(%rbp)
jmp 0xa699
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movslq -0x8(%rbp), %rcx
leaq 0x103a7(%rip), %rax     # 0x1d360
shlq $0x4, %rcx
addq %rcx, %rax
cmpl $-0x1, (%rax)
jne 0xcfde
movl -0x4(%rbp), %ecx
movslq -0x8(%rbp), %rdx
leaq 0x1038d(%rip), %rax     # 0x1d360
shlq $0x4, %rdx
addq %rdx, %rax
movl %ecx, (%rax)
jmp 0xd03e
movslq -0x8(%rbp), %rcx
leaq 0x10377(%rip), %rax     # 0x1d360
shlq $0x4, %rcx
addq %rcx, %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
je 0xd00d
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xcff4
callq 0xc870
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/anuwu[P]ERPLAG-Compiler/parser.c
// Function: initnode
node * initnode(int l){
	node * tmp = (node*)malloc(sizeof(node));
	tmp->key = (tokenID) l;
	tmp->next = NULL;

	return tmp;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl $0x10, %edi
callq 0x10e0
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rbp), %rax
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %eax
movl %eax, %ecx
leaq 0x27f06(%rip), %rax     # 0x369b0
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
cmpl -0x8(%rbp), %eax
je 0xeb00
jmp 0xeabf
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0xeadf
movl -0x8(%rbp), %edi
callq 0xdfe0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0xeb00
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl (%rax), %eax
cmpl -0x8(%rbp), %eax
jne 0xeaf0
jmp 0xeb00
jmp 0xeaf2
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xeabf
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x4(%rbp), %eax
movl %eax, %ecx
leaq 0x27846(%rip), %rax     # 0x36370
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
cmpl -0x8(%rbp), %eax
je 0xeb80
jmp 0xeb3f
movq -0x10(%rbp), %rax
cmpq $0x0, 0x8(%rax)
jne 0xeb5f
movl -0x8(%rbp), %edi
callq 0xdfe0
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
jmp 0xeb80
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movl (%rax), %eax
cmpl -0x8(%rbp), %eax
jne 0xeb70
jmp 0xeb80
jmp 0xeb72
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xeb3f
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
subq $0x30, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, %ecx
leaq 0x27e06(%rip), %rax     # 0x369b0
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movl -0x4(%rbp), %eax
movl %eax, %ecx
leaq 0x27df2(%rip), %rax     # 0x369b0
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x10(%rbp)
jne 0xebd2
jmp 0xec90
cmpq $0x0, -0x18(%rbp)
jne 0xec5d
movq -0x10(%rbp), %rax
movl (%rax), %edi
callq 0xdfe0
movq %rax, %rdx
movl -0x4(%rbp), %eax
movl %eax, %ecx
leaq 0x27db9(%rip), %rax     # 0x369b0
movq %rdx, (%rax,%rcx,8)
movl -0x4(%rbp), %eax
movl %eax, %ecx
leaq 0x27da9(%rip), %rax     # 0x369b0
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xec5b
movq -0x10(%rbp), %rax
cmpl $0x36, (%rax)
je 0xec4d
movq -0x10(%rbp), %rax
movl (%rax), %edi
callq 0xdfe0
movq %rax, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xec1b
jmp 0xec90
jmp 0xec5f
cmpq $0x0, -0x10(%rbp)
je 0xec8e
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
cmpl $0x36, -0x24(%rbp)
je 0xec80
movl -0x4(%rbp), %edi
movl -0x24(%rbp), %esi
callq 0xea90
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xec5f
jmp 0xec90
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl %eax, %ecx
leaq 0x27cfd(%rip), %rax     # 0x369b0
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, -0x10(%rbp)
je 0xece2
movq -0x10(%rbp), %rax
cmpl $0x36, (%rax)
jne 0xecd4
movl $0x1, -0x4(%rbp)
jmp 0xece9
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rbp)
jmp 0xecbb
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop