LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/martinda3[P]Compiler/src/ASifState.cpp
// Function: toyc::ASifState::ASifState(toyc::ASexpression*, toyc::ASstatement*, toyc::ASstatement*)
ASifState::ASifState(ASexpression* oper1, ASstatement* oper2, ASstatement* oper3)
	{
		op1 = oper1;
		op2 = oper2;
		op3 = oper3;
		hasop = true;
		setType(IFstate);
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r13
callq 0x13250
leaq 0x20aab(%rip), %rax     # 0x2ab58
movq %rax, (%r13)
leaq 0x28(%r13), %rbx
leaq 0x38(%r13), %rax
movq %rax, 0x28(%r13)
andq $0x0, 0x30(%r13)
movb $0x0, 0x38(%r13)
movq %r12, 0x10(%r13)
movq %r15, 0x18(%r13)
movq %r14, 0x20(%r13)
movb $0x1, 0x48(%r13)
pushq $0x3
popq %rsi
movq %r13, %rdi
callq 0x13262
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x8478
movq %r14, %rdi
callq 0x8400
// File: /workspace/github_cpp_makefile_star2_O2/martinda3[P]Compiler/src/ASifState.cpp
// Function: toyc::ASifState::ASifState(toyc::ASexpression*, toyc::ASstatement*)
ASifState::ASifState(ASexpression* oper1, ASstatement* oper2)
	{
		op1 = oper1;
		op2 = oper2;
		hasop = false;
		setType(IFstate);
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
callq 0x13250
leaq 0x20a3b(%rip), %rax     # 0x2ab58
movq %rax, (%r12)
leaq 0x28(%r12), %rbx
leaq 0x38(%r12), %rax
movq %rax, 0x28(%r12)
andq $0x0, 0x30(%r12)
xorl %eax, %eax
movb %al, 0x38(%r12)
movq %r15, 0x10(%r12)
movq %r14, 0x18(%r12)
movb %al, 0x48(%r12)
pushq $0x3
popq %rsi
movq %r12, %rdi
callq 0x13262
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x8478
movq %r14, %rdi
callq 0x8400
// File: /workspace/github_cpp_makefile_star2_O2/martinda3[P]Compiler/src/TCparser.cpp
// Function: toyc::TCparser::program()
ASprogram* TCparser::program()
	{
		enteringDEBUG("Program");   //  Need to call DefinitionList to recirsivly repeat
		ASdefinition* definitionList[MAX_STATEMENTS];
		symTable = new TCsymTable();
		int num = DefinitionList(definitionList, 0);
		exitingDEBUG("Program");
		return new ASprog(inputFileName, definitionList, num);
	}

// Assembly:
pushq %r14
pushq %rbx
subq $0x1018, %rsp           # imm = 0x1018
movq %rdi, %rbx
leaq 0x12b12(%rip), %rsi     # 0x1d104
leaq 0x50(%rsp), %rdi
leaq 0x70(%rsp), %rdx
callq 0xd770
leaq 0x50(%rsp), %rdi
callq 0xa70a
leaq 0x50(%rsp), %rdi
callq 0x8478
movl $0x328, %edi            # imm = 0x328
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x1bbf4
leaq 0x22f37(%rip), %rax     # 0x2d568
movq %r14, (%rax)
leaq 0x70(%rsp), %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0xa948
movl %eax, %ebx
leaq 0x12ab8(%rip), %rsi     # 0x1d104
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xd770
leaq 0x30(%rsp), %rdi
callq 0xa888
leaq 0x30(%rsp), %rdi
callq 0x8478
movl $0xfd8, %edi            # imm = 0xFD8
callq 0x8250
movq %rax, %r14
leaq 0x22e65(%rip), %rsi     # 0x2d4e8
leaq 0x10(%rsp), %rdi
callq 0x82f0
leaq 0x10(%rsp), %rsi
leaq 0x70(%rsp), %rdx
movq %r14, %rdi
movl %ebx, %ecx
callq 0x1a288
leaq 0x10(%rsp), %rdi
callq 0x8478
movq %r14, %rax
addq $0x1018, %rsp           # imm = 0x1018
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x8478
jmp 0xa6cb
movq %rax, %rbx
movl $0xfd8, %esi            # imm = 0xFD8
jmp 0xa6e6
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
jmp 0xa6f8
jmp 0xa6ff
movq %rax, %rbx
movl $0x328, %esi            # imm = 0x328
movq %r14, %rdi
callq 0x8260
jmp 0xa702
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x8478
jmp 0xa702
movq %rax, %rbx
movq %rbx, %rdi
callq 0x8400
// File: /workspace/github_cpp_makefile_star2_O2/martinda3[P]Compiler/src/TCparser.cpp
// Function: toyc::TCparser::DefinitionList(toyc::ASdefinition**, int)
int TCparser::DefinitionList(ASdefinition* l[], int n)
	{
		int num = 0;

		enteringDEBUG("Definition List");
		if (!(buff->getTokenType() == EOFILE))
		{
			l[n] = Definition();
			num = DefinitionList(l, n + 1);
		}
		else
		{
			num = n;
		}
		exitingDEBUG("Definition List");
		return num;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movl %edx, %ebx
movq %rsi, %r14
movq %rdi, %r15
leaq 0x127ac(%rip), %rsi     # 0x1d10c
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xd770
leaq 0x30(%rsp), %rdi
callq 0xa70a
leaq 0x30(%rsp), %rdi
callq 0x8478
movq 0x8(%r15), %rdi
callq 0x119f0
cmpl $0x2d, %eax
je 0xa9af
movq %r15, %rdi
callq 0xaa0c
movslq %ebx, %rdx
movq %rax, (%r14,%rdx,8)
incl %edx
movq %r15, %rdi
movq %r14, %rsi
callq 0xa948
movl %eax, %ebx
leaq 0x12756(%rip), %rsi     # 0x1d10c
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xd770
leaq 0x10(%rsp), %rdi
callq 0xa888
leaq 0x10(%rsp), %rdi
callq 0x8478
movl %ebx, %eax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
jmp 0xa9f9
jmp 0xaa00
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x8478
jmp 0xaa03
movq %rax, %rbx
movq %rbx, %rdi
callq 0x8400
nop
// File: /workspace/github_cpp_makefile_star2_O2/martinda3[P]Compiler/src/TCparser.cpp
// Function: toyc::TCparser::Type()
AStype* TCparser::Type() // Functional Needs testing
	{
		// Type --> INT | CHAR
		TCtoken *t1, *t2;
		enteringDEBUG("Type");
		AStype* operand = NULL;
		if (buff->getTokenType() == INT)
		{
			t1 = buff;
			accept(INT);
			t2 = buff;
			operand = new AStype(t1, t2);
			exitingDEBUG(operand->toString());
			exitingDEBUG("Type");
		}
		else if (buff->getTokenType() == CHAR)
		{
			t1 = buff;
			accept(CHAR);
			t2 = buff;
			operand = new AStype(t1, t2);
			exitingDEBUG("Type");
		}
		else        // Error Handlding
		{
			reportSEMANTIC_ERROR(scanner, "type expected");
			exit(EXIT_FAILURE);
		}
		return operand;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xb0, %rsp
movq %rdi, %rbx
leaq 0x12434(%rip), %rsi     # 0x1d138
leaq 0x70(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xd770
leaq 0x70(%rsp), %rdi
callq 0xa70a
leaq 0x70(%rsp), %rdi
callq 0x8478
movq 0x8(%rbx), %rdi
callq 0x119f0
movq 0x8(%rbx), %r14
cmpl $0x3, %eax
jne 0xadb0
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0xaeb8
movq 0x8(%rbx), %r15
pushq $0x18
popq %rdi
callq 0x8250
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1a654
movq (%rbx), %rax
leaq 0x90(%rsp), %r14
movq %r14, %rdi
movq %rbx, %rsi
callq *(%rax)
movq %r14, %rdi
callq 0xa888
leaq 0x90(%rsp), %rdi
callq 0x8478
leaq 0x123a8(%rip), %rsi     # 0x1d138
leaq 0x50(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xd770
leaq 0x50(%rsp), %rdi
callq 0xa888
leaq 0x50(%rsp), %rdi
jmp 0xae0e
movq %r14, %rdi
callq 0x119f0
cmpl $0x5, %eax
jne 0xae23
movq 0x8(%rbx), %r14
pushq $0x5
popq %rsi
movq %rbx, %rdi
callq 0xaeb8
movq 0x8(%rbx), %r15
pushq $0x18
popq %rdi
callq 0x8250
movq %rax, %rbx
movq %rax, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x1a654
leaq 0x12348(%rip), %rsi     # 0x1d138
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xd770
leaq 0x30(%rsp), %rdi
callq 0xa888
leaq 0x30(%rsp), %rdi
callq 0x8478
movq %rbx, %rax
addq $0xb0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq (%rbx), %rbx
leaq 0x12310(%rip), %rsi     # 0x1d13d
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xd770
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x11393
leaq 0x10(%rsp), %rdi
callq 0x8478
pushq $0x1
popq %rdi
callq 0x82c0
movq %rax, %r14
leaq 0x10(%rsp), %rdi
jmp 0xaea6
jmp 0xaead
movq %rax, %r14
leaq 0x30(%rsp), %rdi
jmp 0xaea6
movq %rax, %r14
leaq 0x50(%rsp), %rdi
jmp 0xaea6
jmp 0xaead
jmp 0xaead
jmp 0xae8e
movq %rax, %r14
leaq 0x90(%rsp), %rdi
jmp 0xaea6
movq %rax, %r14
pushq $0x18
popq %rsi
movq %rbx, %rdi
callq 0x8260
jmp 0xaeb0
movq %rax, %r14
leaq 0x70(%rsp), %rdi
callq 0x8478
jmp 0xaeb0
movq %rax, %r14
movq %r14, %rdi
callq 0x8400
// File: /workspace/github_cpp_makefile_star2_O2/martinda3[P]Compiler/src/TCparser.cpp
// Function: toyc::TCparser::FunctionDefinition(toyc::ASdefinition**, int*)
ASstatement* TCparser::FunctionDefinition(ASdefinition* list[], int* i) // DONE NEED TO TEST MORE
	{
		// FunctionDefinition  --> FunctionHeader FunctionBody
		enteringDEBUG("Function Definition");
		ASstatement* operand = NULL;
		*i = FunctionHeader(list);
		operand = FunctionBody();
		exitingDEBUG("Function Definition");
		return operand;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x121cc(%rip), %rsi     # 0x1d14b
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xd770
leaq 0x30(%rsp), %rdi
callq 0xa70a
leaq 0x30(%rsp), %rdi
callq 0x8478
movq %rbx, %rdi
movq %r15, %rsi
callq 0xb018
movl %eax, (%r14)
movq %rbx, %rdi
callq 0xb184
movq %rax, %rbx
leaq 0x12189(%rip), %rsi     # 0x1d14b
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xd770
leaq 0x10(%rsp), %rdi
callq 0xa888
leaq 0x10(%rsp), %rdi
callq 0x8478
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
jmp 0xb006
jmp 0xb00d
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x8478
jmp 0xb010
movq %rax, %rbx
movq %rbx, %rdi
callq 0x8400
// File: /workspace/github_cpp_makefile_star2_O2/martinda3[P]Compiler/src/TCparser.cpp
// Function: toyc::TCparser::FunctionHeader(toyc::ASdefinition**)
int TCparser::FunctionHeader(ASdefinition* list[]) // DONE
	{
		// FunctionHeader --> LPAREN [ FormalParamList ] RPAREN
		enteringDEBUG("Function Header");
		accept(LPAREN);
		int i;
		if (buff->getTokenType() == INT || buff->getTokenType() == CHAR)
		{
			i = FormalParamList(list);
			accept(RPAREN);
			exitingDEBUG("Function Header");
		}
		else if (buff->getTokenType() == RPAREN)
		{
			i = 0;
			accept(RPAREN);
			exitingDEBUG("Function Header");
		}
		else      // Error Handlding
		{
			reportSEMANTIC_ERROR(scanner, "type or ')' expected");
			exit(EXIT_FAILURE);
		}
		return i;
	}

// Assembly:
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x12130(%rip), %rsi     # 0x1d15f
leaq 0x68(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xd770
leaq 0x68(%rsp), %rdi
callq 0xa70a
leaq 0x68(%rsp), %rdi
callq 0x8478
pushq $0x1e
popq %rsi
movq %rbx, %rdi
callq 0xaeb8
movq 0x8(%rbx), %rdi
callq 0x119f0
cmpl $0x3, %eax
je 0xb079
movq 0x8(%rbx), %rdi
callq 0x119f0
cmpl $0x5, %eax
jne 0xb0be
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb21a
pushq $0x1f
popq %rsi
movq %rbx, %rdi
callq 0xaeb8
leaq 0x120c9(%rip), %rsi     # 0x1d15f
leaq 0x48(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xd770
leaq 0x48(%rsp), %rdi
callq 0xa888
leaq 0x48(%rsp), %rdi
callq 0x8478
pushq $0x1
popq %rax
jmp 0xb103
movq 0x8(%rbx), %rdi
callq 0x119f0
cmpl $0x1f, %eax
jne 0xb10e
pushq $0x1f
popq %rsi
movq %rbx, %rdi
callq 0xaeb8
leaq 0x12081(%rip), %rsi     # 0x1d15f
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xd770
leaq 0x28(%rsp), %rdi
callq 0xa888
leaq 0x28(%rsp), %rdi
callq 0x8478
xorl %eax, %eax
addq $0x88, %rsp
popq %rbx
popq %r14
retq
movq (%rbx), %rbx
leaq 0x12057(%rip), %rsi     # 0x1d16f
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xd770
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x11393
leaq 0x8(%rsp), %rdi
callq 0x8478
pushq $0x1
popq %rdi
callq 0x82c0
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0xb172
jmp 0xb179
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
jmp 0xb172
jmp 0xb179
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
jmp 0xb172
jmp 0xb179
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x8478
jmp 0xb17c
movq %rax, %rbx
movq %rbx, %rdi
callq 0x8400
// File: /workspace/github_cpp_makefile_star2_O2/martinda3[P]Compiler/src/TCparser.cpp
// Function: toyc::TCparser::FunctionBody()
ASstatement* TCparser::FunctionBody()  // DONE NEED TO TEST MORE
	{
		// FunctionBody --> CompoundStatement
		enteringDEBUG("Function Body");
		ASstatement* operand = NULL;
		operand = CompoundStatement();
		//CompoundStatement();
		exitingDEBUG("Function Body");
		return operand;
	}

// Assembly:
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
leaq 0x11ff1(%rip), %rsi     # 0x1d184
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xd770
leaq 0x30(%rsp), %rdi
callq 0xa70a
leaq 0x30(%rsp), %rdi
callq 0x8478
movq %rbx, %rdi
callq 0xb6e6
movq %rax, %rbx
leaq 0x11fbc(%rip), %rsi     # 0x1d184
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xd770
leaq 0x10(%rsp), %rdi
callq 0xa888
leaq 0x10(%rsp), %rdi
callq 0x8478
movq %rbx, %rax
addq $0x50, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
jmp 0xb208
jmp 0xb20f
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x8478
jmp 0xb212
movq %rax, %rbx
movq %rbx, %rdi
callq 0x8400
// File: /workspace/github_cpp_makefile_star2_O2/martinda3[P]Compiler/src/TCparser.cpp
// Function: toyc::TCparser::ExpressionStatement()
ASstatement* TCparser::ExpressionStatement() // WIP
	{
		// ExpressionStatement --> Expression
		enteringDEBUG("Expression Statement");
		ASexpression* operand = NULL;
		operand = Expression();
		exitingDEBUG("Expression Statement");
		accept(SEMICOLON);
		return new ASexprState(operand);
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
leaq 0x11725(%rip), %rsi     # 0x1d212
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xd770
leaq 0x30(%rsp), %rdi
callq 0xa70a
leaq 0x30(%rsp), %rdi
callq 0x8478
movq %rbx, %rdi
callq 0xbbaa
movq %rax, %r14
leaq 0x116f0(%rip), %rsi     # 0x1d212
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xd770
leaq 0x10(%rsp), %rdi
callq 0xa888
leaq 0x10(%rsp), %rdi
callq 0x8478
pushq $0x27
popq %rsi
movq %rbx, %rdi
callq 0xaeb8
pushq $0x38
popq %rdi
callq 0x8250
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x1383c
movq %r15, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
pushq $0x38
popq %rsi
movq %r15, %rdi
callq 0x8260
jmp 0xbba1
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
jmp 0xbb97
jmp 0xbb9e
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x8478
jmp 0xbba1
movq %rax, %rbx
movq %rbx, %rdi
callq 0x8400
nop
// File: /workspace/github_cpp_makefile_star2_O2/martinda3[P]Compiler/src/TCparser.cpp
// Function: toyc::TCparser::Expression()
ASexpression* TCparser::Expression()  // WIP
	{
		// Expression --> RelopExpression { ASSIGNOP RelopExpression }
        std::string cleanup, idd;
		enteringDEBUG("Expression");
		ASexpression* operand = NULL;
		ASexpression* operand2 = NULL;
		ASoperator* operand3 = NULL;
		operand = RelopExpression();
		if (buff->getTokenType() == ASSIGNOP)
		{
			enteringDEBUG("Expression Additional");
			operand3 = new ASoperator(accept(ASSIGNOP));
			operand2 = RelopExpression();
			operand = new ASexpr(operand3, operand2, operand);
			exitingDEBUG("Expression Additional");
		}
		exitingDEBUG("Expression");
		return operand;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq %rdi, %rbx
leaq 0xb8(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorl %ecx, %ecx
movb %cl, (%rax)
leaq 0x98(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %cl, (%rax)
leaq 0x117ae(%rip), %rsi     # 0x1d398
leaq 0x68(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xd770
leaq 0x68(%rsp), %rdi
callq 0xa70a
leaq 0x68(%rsp), %rdi
callq 0x8478
movq %rbx, %rdi
callq 0xcbc8
movq %rax, %r14
movq 0x8(%rbx), %rdi
callq 0x119f0
cmpl $0x15, %eax
jne 0xbcc8
leaq 0x11779(%rip), %rsi     # 0x1d3aa
leaq 0x48(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xd770
leaq 0x48(%rsp), %rdi
callq 0xa70a
leaq 0x48(%rsp), %rdi
callq 0x8478
pushq $0x10
popq %rdi
callq 0x8250
movq %rax, %r15
pushq $0x15
popq %rsi
movq %rbx, %rdi
callq 0xaeb8
movq %r15, %rdi
movq %rax, %rsi
callq 0x1311c
movq %rbx, %rdi
callq 0xcbc8
movq %rax, %r12
pushq $0x48
popq %rdi
callq 0x8250
movq %rax, %rbx
movq %rax, %rdi
movq %r15, %rsi
movq %r12, %rdx
movq %r14, %rcx
callq 0x19ba0
leaq 0x11707(%rip), %rsi     # 0x1d3aa
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xd770
leaq 0x28(%rsp), %rdi
callq 0xa888
leaq 0x28(%rsp), %rdi
callq 0x8478
jmp 0xbccb
movq %r14, %rbx
leaq 0x116c6(%rip), %rsi     # 0x1d398
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xd770
leaq 0x8(%rsp), %rdi
callq 0xa888
leaq 0x8(%rsp), %rdi
callq 0x8478
leaq 0x88(%rsp), %rdi
callq 0x8478
leaq 0xa8(%rsp), %rdi
callq 0x8478
movq %rbx, %rax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x28(%rsp), %rdi
jmp 0xbd68
jmp 0xbd71
movq %rax, %r14
pushq $0x48
popq %rsi
movq %rbx, %rdi
jmp 0xbd59
movq %rax, %r14
leaq 0x48(%rsp), %rdi
jmp 0xbd68
jmp 0xbd71
movq %rax, %r14
leaq 0x8(%rsp), %rdi
jmp 0xbd68
jmp 0xbd71
movq %rax, %r14
pushq $0x10
popq %rsi
movq %r15, %rdi
callq 0x8260
jmp 0xbd74
movq %rax, %r14
leaq 0x68(%rsp), %rdi
callq 0x8478
jmp 0xbd74
jmp 0xbd71
movq %rax, %r14
leaq 0x88(%rsp), %rdi
callq 0x8478
leaq 0xa8(%rsp), %rdi
callq 0x8478
movq %r14, %rdi
callq 0x8400
// File: /workspace/github_cpp_makefile_star2_O2/martinda3[P]Compiler/src/TCparser.cpp
// Function: toyc::TCparser::IfStatement()
ASstatement* TCparser::IfStatement() // WIP
	{
		// IfStatement --> IF LPAREN Expression RPAREN Statement [ ELSE Statement ]
		enteringDEBUG("If Statement");
		ASexpression* operand = NULL;
		ASstatement* operand2 = NULL;
		ASstatement* operand3 = NULL;
		accept(IF);
		accept(LPAREN);
		operand = Expression();
		accept(RPAREN);
		operand2 = Statement();
		if (buff->getTokenType() == ELSE)
		{
			enteringDEBUG("If Statement Additional");
			accept(ELSE);
			operand3 = Statement();
			exitingDEBUG("If Statement Additional");
			exitingDEBUG("If Statement");
			return new ASifState(operand, operand2, operand3);
		}
		exitingDEBUG("If Statement");
		return new ASifState(operand, operand2);
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %r15
leaq 0x11427(%rip), %rsi     # 0x1d25f
leaq 0x88(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xd770
leaq 0x88(%rsp), %rdi
callq 0xa70a
leaq 0x88(%rsp), %rdi
callq 0x8478
pushq $0x1
popq %rsi
movq %r15, %rdi
callq 0xaeb8
pushq $0x1e
popq %rsi
movq %r15, %rdi
callq 0xaeb8
movq %r15, %rdi
callq 0xbbaa
movq %rax, %rbx
pushq $0x1f
popq %rsi
movq %r15, %rdi
callq 0xaeb8
movq %r15, %rdi
callq 0xbd96
movq %rax, %r14
movq 0x8(%r15), %rdi
callq 0x119f0
cmpl $0x4, %eax
jne 0xbf5f
leaq 0x113b8(%rip), %rsi     # 0x1d26c
leaq 0x68(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xd770
leaq 0x68(%rsp), %rdi
callq 0xa70a
leaq 0x68(%rsp), %rdi
callq 0x8478
pushq $0x4
popq %rsi
movq %r15, %rdi
callq 0xaeb8
movq %r15, %rdi
callq 0xbd96
movq %rax, %r15
leaq 0x11378(%rip), %rsi     # 0x1d26c
leaq 0x48(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xd770
leaq 0x48(%rsp), %rdi
callq 0xa888
leaq 0x48(%rsp), %rdi
callq 0x8478
leaq 0x11341(%rip), %rsi     # 0x1d25f
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xd770
leaq 0x28(%rsp), %rdi
callq 0xa888
leaq 0x28(%rsp), %rdi
callq 0x8478
pushq $0x50
popq %rdi
callq 0x8250
movq %rax, %r12
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
movq %r15, %rcx
callq 0xa08c
jmp 0xbfa2
leaq 0x112f9(%rip), %rsi     # 0x1d25f
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xd770
leaq 0x8(%rsp), %rdi
callq 0xa888
leaq 0x8(%rsp), %rdi
callq 0x8478
pushq $0x50
popq %rdi
callq 0x8250
movq %rax, %r12
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0xa100
movq %r12, %rax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0xbfcc
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
jmp 0xc001
jmp 0xc008
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
jmp 0xc001
movq %rax, %rbx
pushq $0x50
popq %rsi
movq %r12, %rdi
callq 0x8260
jmp 0xc00b
jmp 0xc008
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0xc001
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
jmp 0xc001
jmp 0xc008
jmp 0xc008
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0x8478
jmp 0xc00b
movq %rax, %rbx
movq %rbx, %rdi
callq 0x8400
nop
// File: /workspace/github_cpp_makefile_star2_O2/martinda3[P]Compiler/src/TCparser.cpp
// Function: toyc::TCparser::BreakStatement()
ASstatement* TCparser::BreakStatement() // DONE NEED TO TEST
	{
		// BreakStatement --> BREAK SEMICOLON
		enteringDEBUG("Break Statement");
		accept(BREAK);
		accept(SEMICOLON);
		exitingDEBUG("Break Statement");
		return new ASbreakState();
	}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x1125f(%rip), %rsi     # 0x1d284
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xd770
leaq 0x28(%rsp), %rdi
callq 0xa70a
leaq 0x28(%rsp), %rdi
callq 0x8478
pushq $0xb
popq %rsi
movq %rbx, %rdi
callq 0xaeb8
pushq $0x27
popq %rsi
movq %rbx, %rdi
callq 0xaeb8
leaq 0x1121f(%rip), %rsi     # 0x1d284
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xd770
leaq 0x8(%rsp), %rdi
callq 0xa888
leaq 0x8(%rsp), %rdi
callq 0x8478
pushq $0x10
popq %rdi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x12288
movq %r14, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
pushq $0x10
popq %rsi
movq %r14, %rdi
callq 0x8260
jmp 0xc0d4
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0xc0ca
jmp 0xc0d1
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x8478
jmp 0xc0d4
movq %rax, %rbx
movq %rbx, %rdi
callq 0x8400
// File: /workspace/github_cpp_makefile_star2_O2/martinda3[P]Compiler/src/TCparser.cpp
// Function: toyc::TCparser::NullStatement()
ASstatement* TCparser::NullStatement() // DONE NEED TO TEST
	{
		// SEMICOLON
		enteringDEBUG("Null Statement");
		exitingDEBUG("Null Statement");
		accept(SEMICOLON);
		return new ASnullState();
	}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x111a7(%rip), %rsi     # 0x1d294
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xd770
leaq 0x28(%rsp), %rdi
callq 0xa70a
leaq 0x28(%rsp), %rdi
callq 0x8478
leaq 0x1117d(%rip), %rsi     # 0x1d294
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xd770
leaq 0x8(%rsp), %rdi
callq 0xa888
leaq 0x8(%rsp), %rdi
callq 0x8478
pushq $0x27
popq %rsi
movq %rbx, %rdi
callq 0xaeb8
pushq $0x10
popq %rdi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x122fc
movq %r14, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
pushq $0x10
popq %rsi
movq %r14, %rdi
callq 0x8260
jmp 0xc191
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0xc187
jmp 0xc18e
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x8478
jmp 0xc191
movq %rax, %rbx
movq %rbx, %rdi
callq 0x8400
nop
// File: /workspace/github_cpp_makefile_star2_O2/martinda3[P]Compiler/src/TCparser.cpp
// Function: toyc::TCparser::ReturnStatement()
ASstatement* TCparser::ReturnStatement() // WIP
	{
		// RETURN [ Expression ] SEMICOLON
		enteringDEBUG("Return Statement");
		ASexpression* operand = NULL;
		accept(RETURN);
		try
		{
			operand = Expression();
			accept(SEMICOLON);
			exitingDEBUG("Return Statement");
			return new ASreturnState(operand);
		}
		catch (int t)
		{
			accept(SEMICOLON);
			exitingDEBUG("Return Statement");
			return new ASreturnState();
		}
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
leaq 0x110f4(%rip), %rsi     # 0x1d2a3
leaq 0x48(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xd770
leaq 0x48(%rsp), %rdi
callq 0xa70a
leaq 0x48(%rsp), %rdi
callq 0x8478
pushq $0xa
popq %rsi
movq %rbx, %rdi
callq 0xaeb8
movq %rbx, %rdi
callq 0xbbaa
movq %rax, %r14
pushq $0x27
popq %rsi
movq %rbx, %rdi
callq 0xaeb8
leaq 0x110a9(%rip), %rsi     # 0x1d2a3
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xd770
leaq 0x28(%rsp), %rdi
callq 0xa888
leaq 0x28(%rsp), %rdi
callq 0x8478
pushq $0x40
popq %rdi
callq 0x8250
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0x9e6c
movq %r15, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rdx, %r12
movq %rax, %r14
pushq $0x40
popq %rsi
movq %r15, %rdi
callq 0x8260
jmp 0xc289
movq %rdx, %r12
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x8478
jmp 0xc289
jmp 0xc283
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x8478
jmp 0xc27b
movq %rax, %r14
movq %r14, %rdi
callq 0x8400
movq %rdx, %r12
movq %rax, %r14
cmpl $0x1, %r12d
jne 0xc27b
movq %r14, %rdi
callq 0x80e0
pushq $0x27
popq %rsi
movq %rbx, %rdi
callq 0xaeb8
leaq 0x10ffa(%rip), %rsi     # 0x1d2a3
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xd770
leaq 0x8(%rsp), %rdi
callq 0xa888
leaq 0x8(%rsp), %rdi
callq 0x8478
pushq $0x40
popq %rdi
callq 0x8250
movq %rax, %r15
movq %rax, %rdi
callq 0x9eca
callq 0x83b0
jmp 0xc233
movq %rax, %r14
pushq $0x40
popq %rsi
movq %r15, %rdi
callq 0x8260
jmp 0xc30d
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x8478
jmp 0xc30d
jmp 0xc30a
movq %rax, %r14
callq 0x83b0
jmp 0xc27b
nop
// File: /workspace/github_cpp_makefile_star2_O2/martinda3[P]Compiler/src/TCparser.cpp
// Function: toyc::TCparser::WhileStatement()
ASstatement* TCparser::WhileStatement() // Testing
	{
		// WHILE LPAREN Expression RPAREN Statement
		enteringDEBUG("While Statement");
		ASexpression* operand = NULL;
		ASstatement* operand2 = NULL;
		accept(WHILE);
		accept(LPAREN);
		operand = Expression();
		accept(RPAREN);
		operand2 = Statement();
		exitingDEBUG("While Statement");
		return new ASwhileState(operand, operand2);
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
leaq 0x10f89(%rip), %rsi     # 0x1d2b4
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xd770
leaq 0x30(%rsp), %rdi
callq 0xa70a
leaq 0x30(%rsp), %rdi
callq 0x8478
pushq $0x8
popq %rsi
movq %rbx, %rdi
callq 0xaeb8
pushq $0x1e
popq %rsi
movq %rbx, %rdi
callq 0xaeb8
movq %rbx, %rdi
callq 0xbbaa
movq %rax, %r14
pushq $0x1f
popq %rsi
movq %rbx, %rdi
callq 0xaeb8
movq %rbx, %rdi
callq 0xbd96
movq %rax, %rbx
leaq 0x10f28(%rip), %rsi     # 0x1d2b4
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xd770
leaq 0x10(%rsp), %rdi
callq 0xa888
leaq 0x10(%rsp), %rdi
callq 0x8478
pushq $0x20
popq %rdi
callq 0x8250
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x128dc
movq %r15, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
pushq $0x20
popq %rsi
movq %r15, %rdi
callq 0x8260
jmp 0xc403
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
jmp 0xc3f9
jmp 0xc400
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x8478
jmp 0xc403
movq %rax, %rbx
movq %rbx, %rdi
callq 0x8400
nop
// File: /workspace/github_cpp_makefile_star2_O2/martinda3[P]Compiler/src/TCparser.cpp
// Function: toyc::TCparser::WriteStatement()
ASstatement* TCparser::WriteStatement() // WIP
	{
		// WriteStatement -> WRITE LPAREN ActualParameters RPAREN SEMICOLON
		enteringDEBUG("Write Statement");
		ASexpression* operand = NULL;
		ASexpression* operand2[MAX_STATEMENTS];
		accept(WRITE);
        enter_special_id(symTable,WRITE);
		accept(LPAREN);
		operand = ActualParameters();
		operand2[0] = operand;
		accept(RPAREN);
		exitingDEBUG("Write Statement");
		accept(SEMICOLON);
		return new ASwriteState(operand2, 1);
	}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0xff0, %rsp            # imm = 0xFF0
movq %rdi, %rbx
leaq 0x10b68(%rip), %rsi     # 0x1d327
leaq 0x30(%rsp), %rdi
leaq 0x50(%rsp), %rdx
callq 0xd770
leaq 0x30(%rsp), %rdi
callq 0xa70a
leaq 0x30(%rsp), %rdi
callq 0x8478
pushq $0xc
popq %rbp
movq %rbx, %rdi
movl %ebp, %esi
callq 0xaeb8
leaq 0x20d72(%rip), %rax     # 0x2d568
movq (%rax), %rdi
movl %ebp, %esi
callq 0xc984
pushq $0x1e
popq %rsi
movq %rbx, %rdi
callq 0xaeb8
movq %rbx, %rdi
callq 0xca42
movq %rax, 0x50(%rsp)
pushq $0x1f
popq %rsi
movq %rbx, %rdi
callq 0xaeb8
leaq 0x10afd(%rip), %rsi     # 0x1d327
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xd770
leaq 0x10(%rsp), %rdi
callq 0xa888
leaq 0x10(%rsp), %rdi
callq 0x8478
pushq $0x27
popq %rsi
movq %rbx, %rdi
callq 0xaeb8
movl $0xfb8, %edi            # imm = 0xFB8
callq 0x8250
movq %rax, %r14
leaq 0x50(%rsp), %rsi
pushq $0x1
popq %rdx
movq %rax, %rdi
callq 0x12e74
movq %r14, %rax
addq $0xff0, %rsp            # imm = 0xFF0
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movl $0xfb8, %esi            # imm = 0xFB8
movq %r14, %rdi
callq 0x8260
jmp 0xc8b4
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
jmp 0xc8aa
jmp 0xc8b1
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x8478
jmp 0xc8b4
movq %rax, %rbx
movq %rbx, %rdi
callq 0x8400
// File: /workspace/github_cpp_makefile_star2_O2/martinda3[P]Compiler/src/TCparser.cpp
// Function: toyc::TCparser::NewLineStatement()
ASstatement* TCparser::NewLineStatement() // WIP
	{
		// NewLineStatement --> NEWLINE SEMICOLON
		enteringDEBUG("NewLine Statement");
		accept(NEWLINE);
		exitingDEBUG("NewLine Statement");
		accept(SEMICOLON);
		return new ASnewLineState();
	}

// Assembly:
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x10a6a(%rip), %rsi     # 0x1d337
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xd770
leaq 0x28(%rsp), %rdi
callq 0xa70a
leaq 0x28(%rsp), %rdi
callq 0x8478
pushq $0xf
popq %rsi
movq %rbx, %rdi
callq 0xaeb8
leaq 0x10a35(%rip), %rsi     # 0x1d337
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xd770
leaq 0x8(%rsp), %rdi
callq 0xa888
leaq 0x8(%rsp), %rdi
callq 0x8478
pushq $0x27
popq %rsi
movq %rbx, %rdi
callq 0xaeb8
pushq $0x10
popq %rdi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x139c8
movq %r14, %rax
addq $0x48, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
pushq $0x10
popq %rsi
movq %r14, %rdi
callq 0x8260
jmp 0xc97c
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0xc972
jmp 0xc979
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x8478
jmp 0xc97c
movq %rax, %rbx
movq %rbx, %rdi
callq 0x8400
// File: /workspace/github_cpp_makefile_star2_O2/martinda3[P]Compiler/src/TCparser.cpp
// Function: toyc::enter_special_id(toyc::TCsymTable*, toyc::tokens)
static void enter_special_id(TCsymTable *st,tokens type) {
	    int offffset;
        TCsymbol *sym = new TCsymbol();
        sym->setType(OFFSET);
        sym->setId((type==READ)?"System.in":"System.out");
        offffset = _nextOffset;
        sym->setOffset(offffset);
        sym->getNextOffset();
        st->add(sym);
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movl %esi, %ebp
movq %rdi, %r14
pushq $0x48
popq %rdi
callq 0x8250
movq %rax, %rbx
movq %rax, %rdi
callq 0x13a3c
pushq $0x2
popq %rsi
movq %rbx, %rdi
callq 0x13b1c
cmpl $0x7, %ebp
leaq 0x10ac2(%rip), %rax     # 0x1d47b
leaq 0x10ac5(%rip), %rsi     # 0x1d485
cmoveq %rax, %rsi
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xd770
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x13b12
leaq 0x10(%rsp), %rdi
callq 0x8478
leaq 0x2086b(%rip), %rax     # 0x2d25c
movl (%rax), %esi
movq %rbx, %rdi
callq 0x13b54
movq %rbx, %rdi
callq 0x13b58
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1bbfc
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x8478
jmp 0xca39
movq %rax, %r14
jmp 0xca39
movq %rax, %r14
pushq $0x48
popq %rsi
movq %rbx, %rdi
callq 0x8260
movq %r14, %rdi
callq 0x8400
nop
// File: /workspace/github_cpp_makefile_star2_O2/martinda3[P]Compiler/src/TCparser.cpp
// Function: toyc::TCparser::ActualParameters()
ASexpression* TCparser::ActualParameters() // WIP
	{
		// ActualParameters -> Expression { COMMA Expression }
		enteringDEBUG("Actual Parameters");
		ASexpression* operand = NULL;
		ASexpression* operand2[MAX_STATEMENTS];
		int i = 0;
		operand = Expression();
		while (buff->getTokenType() == COMMA)
		{
			enteringDEBUG("Actual Parameters Additional");
			accept(COMMA);
			operand2[i] = Expression();
			i++;
			exitingDEBUG("Actual Parameters Additional");
		}
		operand = new ASfuncCall(operand, operand2, i);
		exitingDEBUG("Actual Parameters");
		return operand;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1038, %rsp           # imm = 0x1038
movq %rdi, %rbx
leaq 0x109ef(%rip), %rsi     # 0x1d44c
leaq 0x30(%rsp), %rdi
leaq 0x90(%rsp), %rdx
callq 0xd770
leaq 0x30(%rsp), %rdi
callq 0xa70a
leaq 0x30(%rsp), %rdi
callq 0x8478
movq %rbx, %rdi
callq 0xbbaa
movq %rax, 0x8(%rsp)
xorl %r14d, %r14d
leaq 0x109c4(%rip), %r12     # 0x1d45e
leaq 0x70(%rsp), %r13
leaq 0x7(%rsp), %rbp
leaq 0x50(%rsp), %r15
movq 0x8(%rbx), %rdi
callq 0x119f0
cmpl $0x26, %eax
jne 0xcb13
movq %r13, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0xd770
movq %r13, %rdi
callq 0xa70a
movq %r13, %rdi
callq 0x8478
movq %rbx, %rdi
pushq $0x26
popq %rsi
callq 0xaeb8
movq %rbx, %rdi
callq 0xbbaa
movq %rax, 0x90(%rsp,%r14,8)
movq %r15, %rdi
movq %r12, %rsi
movq %rbp, %rdx
callq 0xd770
movq %r15, %rdi
callq 0xa888
movq %r15, %rdi
callq 0x8478
incq %r14
jmp 0xcaa9
movl $0xfc0, %edi            # imm = 0xFC0
callq 0x8250
movq %rax, %r15
leaq 0x90(%rsp), %rdx
movq %rax, %rdi
movq 0x8(%rsp), %rsi
movl %r14d, %ecx
callq 0x134e4
leaq 0x1090d(%rip), %rsi     # 0x1d44c
leaq 0x10(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xd770
leaq 0x10(%rsp), %rdi
callq 0xa888
leaq 0x10(%rsp), %rdi
callq 0x8478
movq %r15, %rax
addq $0x1038, %rsp           # imm = 0x1038
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
jmp 0xcbba
jmp 0xcbad
movq %rax, %rbx
movl $0xfc0, %esi            # imm = 0xFC0
movq %r15, %rdi
callq 0x8260
jmp 0xcbbf
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
jmp 0xcbba
jmp 0xcbad
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
jmp 0xcbba
jmp 0xcbad
movq %rax, %rbx
jmp 0xcbbf
movq %rax, %rbx
leaq 0x70(%rsp), %rdi
callq 0x8478
movq %rbx, %rdi
callq 0x8400
nop
// File: /workspace/github_cpp_makefile_star2_O2/martinda3[P]Compiler/src/TCparser.cpp
// Function: toyc::TCparser::RelopExpression()
ASexpression* TCparser::RelopExpression() // WIP
	{
		// RelopExpression --> SimpleExpression { RELOP SimpleExpression }
		enteringDEBUG("Relop Expression");
		ASexpression* operand = NULL;
		ASexpression* operand2 = NULL;
		ASoperator* operand3 = NULL;
		operand = SimpleExpression();
		while (buff->getTokenType() == RELOP)
		{
			enteringDEBUG("Relop Expression Additional");
			operand3 = new ASoperator(accept(RELOP));
			operand2 = SimpleExpression();
			operand = new ASexpr(operand3, operand2, operand);
			exitingDEBUG("RelopExpression Additional");
		}
		exitingDEBUG("Relop Expression");
		return operand;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbp
leaq 0x10766(%rip), %rsi     # 0x1d349
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xd770
leaq 0x28(%rsp), %rdi
callq 0xa70a
leaq 0x28(%rsp), %rdi
callq 0x8478
movq %rbp, %rdi
callq 0xcd6a
movq %rax, %r12
leaq 0x48(%rsp), %rbx
leaq 0x7(%rsp), %r13
movq 0x8(%rbp), %rdi
callq 0x119f0
cmpl $0x12, %eax
jne 0xccd1
movq %rbx, %rdi
leaq 0x10723(%rip), %rsi     # 0x1d35a
movq %r13, %rdx
callq 0xd770
movq %rbx, %rdi
callq 0xa70a
movq %rbx, %rdi
callq 0x8478
pushq $0x10
popq %rdi
callq 0x8250
movq %rax, %r15
movq %rbp, %rdi
pushq $0x12
popq %rsi
callq 0xaeb8
movq %r15, %rdi
movq %rax, %rsi
callq 0x1311c
movq %rbp, %rbx
movq %rbp, %rdi
callq 0xcd6a
movq %rax, %rbp
pushq $0x48
popq %rdi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
movq %rbp, %rdx
movq %r12, %rcx
callq 0x19ba0
leaq 0x68(%rsp), %r12
movq %r12, %rdi
leaq 0x106cd(%rip), %rsi     # 0x1d376
movq %r13, %rdx
callq 0xd770
movq %r12, %rdi
callq 0xa888
movq %rbx, %rbp
movq %r12, %rdi
callq 0x8478
movq %r14, %r12
leaq 0x48(%rsp), %rbx
jmp 0xcc1b
leaq 0x10671(%rip), %rsi     # 0x1d349
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xd770
leaq 0x8(%rsp), %rdi
callq 0xa888
leaq 0x8(%rsp), %rdi
callq 0x8478
movq %r12, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0xcd3c
jmp 0xcd43
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
jmp 0xcd3c
jmp 0xcd43
jmp 0xcd43
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
jmp 0xcd3c
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x8478
jmp 0xcd61
movq %rax, %rbx
jmp 0xcd61
movq %rax, %rbx
pushq $0x48
popq %rsi
movq %r14, %rdi
jmp 0xcd5c
movq %rax, %rbx
pushq $0x10
popq %rsi
movq %r15, %rdi
callq 0x8260
movq %rbx, %rdi
callq 0x8400
nop
// File: /workspace/github_cpp_makefile_star2_O2/martinda3[P]Compiler/src/TCparser.cpp
// Function: toyc::TCparser::SimpleExpression()
ASexpression* TCparser::SimpleExpression() // WIP
	{
		// SimpleExpression --> Term { ADDOP Term }
		enteringDEBUG("Simple Expression");
		ASexpression* operand = NULL;
		ASexpression* operand2 = NULL;
		ASoperator* operand3 = NULL;
		operand = Term();
		while (buff->getTokenType() == ADDOP)
		{
			enteringDEBUG("Simple Expression Additional");
			operand3 = new ASoperator(accept(ADDOP));
			operand2 = Term();
			operand = new ASexpr(operand3, operand2, operand);
			exitingDEBUG("SimpleExpression Additional");
		}
		exitingDEBUG("Simple Expression");
		return operand;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbp
leaq 0x1060c(%rip), %rsi     # 0x1d391
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xd770
leaq 0x28(%rsp), %rdi
callq 0xa70a
leaq 0x28(%rsp), %rdi
callq 0x8478
movq %rbp, %rdi
callq 0xcf0c
movq %rax, %r12
leaq 0x48(%rsp), %rbx
leaq 0x7(%rsp), %r13
movq 0x8(%rbp), %rdi
callq 0x119f0
cmpl $0x13, %eax
jne 0xce73
movq %rbx, %rdi
leaq 0x105ca(%rip), %rsi     # 0x1d3a3
movq %r13, %rdx
callq 0xd770
movq %rbx, %rdi
callq 0xa70a
movq %rbx, %rdi
callq 0x8478
pushq $0x10
popq %rdi
callq 0x8250
movq %rax, %r15
movq %rbp, %rdi
pushq $0x13
popq %rsi
callq 0xaeb8
movq %r15, %rdi
movq %rax, %rsi
callq 0x1311c
movq %rbp, %rbx
movq %rbp, %rdi
callq 0xcf0c
movq %rax, %rbp
pushq $0x48
popq %rdi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
movq %r15, %rsi
movq %rbp, %rdx
movq %r12, %rcx
callq 0x19ba0
leaq 0x68(%rsp), %r12
movq %r12, %rdi
leaq 0x10575(%rip), %rsi     # 0x1d3c0
movq %r13, %rdx
callq 0xd770
movq %r12, %rdi
callq 0xa888
movq %rbx, %rbp
movq %r12, %rdi
callq 0x8478
movq %r14, %r12
leaq 0x48(%rsp), %rbx
jmp 0xcdbd
leaq 0x10517(%rip), %rsi     # 0x1d391
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xd770
leaq 0x8(%rsp), %rdi
callq 0xa888
leaq 0x8(%rsp), %rdi
callq 0x8478
movq %r12, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0xcede
jmp 0xcee5
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
jmp 0xcede
jmp 0xcee5
jmp 0xcee5
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
jmp 0xcede
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x8478
jmp 0xcf03
movq %rax, %rbx
jmp 0xcf03
movq %rax, %rbx
pushq $0x48
popq %rsi
movq %r14, %rdi
jmp 0xcefe
movq %rax, %rbx
pushq $0x10
popq %rsi
movq %r15, %rdi
callq 0x8260
movq %rbx, %rdi
callq 0x8400
nop
// File: /workspace/github_cpp_makefile_star2_O2/martinda3[P]Compiler/src/TCparser.cpp
// Function: toyc::TCparser::FunctionCall()
ASexpression* TCparser::FunctionCall() // WIP
	{
		// FunctionCall -- > LPAREN ActualParameters RPAREN
		enteringDEBUG("Function Call");
		ASexpression* operand = NULL;
		accept(LPAREN);
		try { operand = ActualParameters(); }
		catch (int t) { operand = new ASexpression(); }
		accept(RPAREN);
		exitingDEBUG("Function Call");
		return operand;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
leaq 0xfdb3(%rip), %rsi      # 0x1d43e
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xd770
leaq 0x30(%rsp), %rdi
callq 0xa70a
leaq 0x30(%rsp), %rdi
callq 0x8478
pushq $0x1e
popq %rsi
movq %rbx, %rdi
callq 0xaeb8
movq %rbx, %rdi
callq 0xca42
movq %rax, %r14
pushq $0x1f
popq %rsi
movq %rbx, %rdi
callq 0xaeb8
leaq 0xfd68(%rip), %rsi      # 0x1d43e
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xd770
leaq 0x10(%rsp), %rdi
callq 0xa888
leaq 0x10(%rsp), %rdi
callq 0x8478
movq %r14, %rax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r15
leaq 0x10(%rsp), %rdi
jmp 0xd75e
jmp 0xd765
movq %rax, %r15
cmpl $0x1, %edx
jne 0xd768
movq %r15, %rdi
callq 0x80e0
pushq $0x10
popq %rdi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x13d4c
callq 0x83b0
jmp 0xd6c4
movq %rax, %r15
pushq $0x10
popq %rsi
movq %r14, %rdi
callq 0x8260
jmp 0xd74f
movq %rax, %r15
callq 0x83b0
jmp 0xd768
movq %rax, %r15
leaq 0x30(%rsp), %rdi
callq 0x8478
jmp 0xd768
movq %rax, %r15
movq %r15, %rdi
callq 0x8400
// File: /workspace/github_cpp_makefile_star2_O2/martinda3[P]Compiler/src/ASfuncDef.cpp
// Function: toyc::ASfuncDef::ASfuncDef(toyc::AStype*, toyc::ASdefinition**, int, toyc::ASstatement*)
ASfuncDef::ASfuncDef(AStype* id, ASdefinition* varDef[], int num, ASstatement* s)
	{
		identifier = id;
		for (int i = 0; i < num; i++)
		{
			varDefList[i] = varDef[i];
		}
		numVarDef = num;
		statement = s;
		setType(FUNCdef);
	}

// Assembly:
leaq 0x1d2bd(%rip), %rax     # 0x2ab88
movq %rax, (%rdi)
movq %rsi, 0x10(%rdi)
xorl %eax, %eax
testl %ecx, %ecx
movl $0x0, %esi
cmovgl %ecx, %esi
cmpq %rax, %rsi
je 0xd8f1
movq (%rdx,%rax,8), %r9
movq %r9, 0x18(%rdi,%rax,8)
incq %rax
jmp 0xd8de
movl %ecx, 0xfb8(%rdi)
movq %r8, 0xfc0(%rdi)
xorl %esi, %esi
jmp 0x19b3c
nop
// File: /workspace/github_cpp_makefile_star2_O2/martinda3[P]Compiler/src/TClexer.cpp
// Function: toyc::getNextLine[abi:cxx11]()
std::string getNextLine()
	{
		std::string line, num;
		std::getline(infile, line);
		line = line + " ";
		pos = 0;
		lineNum++;
		if (lineNum < 10) {num = "  ";}
		else if (lineNum < 99) {num = " ";}
		else if (lineNum < 999) {num = "";}
		num += std::to_string(lineNum);
		if (verbose) reportDEBUG(" ", "INPUT", " " + num + ": " + line);
		return line;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
xorl %eax, %eax
movb %al, 0x10(%rdi)
leaq 0x40(%rsp), %rcx
movq %rcx, -0x10(%rcx)
andq $0x0, -0x8(%rcx)
movb %al, (%rcx)
leaq 0x1c500(%rip), %rdi     # 0x2d2b8
movq %rbx, %rsi
callq 0x8070
leaq 0xc32c(%rip), %r14      # 0x1d0f3
leaq 0x10(%rsp), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x110f1
leaq 0x10(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x82d0
movq %r15, %rdi
callq 0x8478
andl $0x0, 0x1c6ca(%rip)     # 0x2d4c0
movl 0x1c6d0(%rip), %eax     # 0x2d4cc
leal 0x1(%rax), %ecx
movl %ecx, 0x1c6c7(%rip)     # 0x2d4cc
cmpl $0x9, %eax
jge 0x10e13
leaq 0xc2e1(%rip), %r14      # 0x1d0f2
jmp 0x10e26
cmpl $0x62, %eax
jb 0x10e26
cmpl $0x3e5, %eax            # imm = 0x3E5
ja 0x10e33
leaq 0xd734(%rip), %r14      # 0x1e55a
leaq 0x30(%rsp), %rdi
movq %r14, %rsi
callq 0x8440
movl 0x1c693(%rip), %esi     # 0x2d4cc
leaq 0x10(%rsp), %rdi
callq 0x11076
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x8450
leaq 0x10(%rsp), %rdi
callq 0x8478
leaq 0x1c76d(%rip), %rax     # 0x2d5d0
cmpb $0x1, (%rax)
jne 0x10f2e
leaq 0xc280(%rip), %rsi      # 0x1d0f3
leaq 0xb0(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0xd770
leaq 0xc8c4(%rip), %rsi      # 0x1d750
leaq 0x90(%rsp), %rdi
leaq 0xe(%rsp), %rdx
callq 0xd770
leaq 0xc24e(%rip), %rsi      # 0x1d0f3
leaq 0x50(%rsp), %rdi
leaq 0x30(%rsp), %rdx
callq 0xd7ab
leaq 0xd039(%rip), %rdx      # 0x1def4
leaq 0x10(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0xa06b
leaq 0x70(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq %rbx, %rdx
callq 0x11129
leaq 0xb0(%rsp), %rdi
leaq 0x90(%rsp), %rsi
leaq 0x70(%rsp), %rdx
callq 0x11220
leaq 0x70(%rsp), %rdi
callq 0x8478
leaq 0x10(%rsp), %rdi
callq 0x8478
leaq 0x50(%rsp), %rdi
callq 0x8478
leaq 0x90(%rsp), %rdi
callq 0x8478
leaq 0xb0(%rsp), %rdi
callq 0x8478
leaq 0x30(%rsp), %rdi
callq 0x8478
movq %rbx, %rax
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x70(%rsp), %rdi
callq 0x8478
jmp 0x10f5a
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x8478
jmp 0x10f69
movq %rax, %r14
leaq 0x50(%rsp), %rdi
callq 0x8478
jmp 0x10f78
movq %rax, %r14
leaq 0x90(%rsp), %rdi
callq 0x8478
jmp 0x10f8a
movq %rax, %r14
leaq 0xb0(%rsp), %rdi
jmp 0x10f9e
jmp 0x10fa9
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x8478
jmp 0x10fac
jmp 0x10fa9
jmp 0x10fa9
movq %rax, %r14
leaq 0x30(%rsp), %rdi
callq 0x8478
movq %rbx, %rdi
callq 0x8478
movq %r14, %rdi
callq 0x8400
// File: /workspace/github_cpp_makefile_star2_O2/martinda3[P]Compiler/src/TCoutput.cpp
// Function: toyc::reportSEMANTIC_ERROR(toyc::TClexer*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void reportSEMANTIC_ERROR(TClexer *l, std::string message) {
        int ln;
        std::string lnstr;
        std::string sep = ": ";
        std::cerr << (ln = l->getLineNum()) << sep << l->getLine() << std::endl;
        lnstr += ln;
        std::cerr <<
                  pad(lnstr.length()) <<
                  pad(l->getPos() + sep.length() - (l->getLexeme().length()) + 1) <<
                  "^ %error: " << message << std::endl;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x50(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0xcb34(%rip), %rsi      # 0x1def4
leaq 0x20(%rsp), %rdi
movq %rsp, %rdx
callq 0xd770
movq %r14, %rdi
callq 0x10ffa
movl %eax, %ebp
movq 0x1bc12(%rip), %rdi     # 0x2cff0
movl %eax, %esi
callq 0x83f0
leaq 0x20(%rsp), %rsi
movq %rax, %rdi
callq 0x8210
movq %rax, %r15
movq %rsp, %rdi
movq %r14, %rsi
callq 0x10fc6
movq %rsp, %rsi
movq %r15, %rdi
callq 0x8210
movq %rax, %rdi
callq 0x8130
movq %rsp, %rdi
callq 0x8478
movsbl %bpl, %esi
leaq 0x40(%rsp), %rdi
callq 0x81e0
movl 0x48(%rsp), %esi
movq %rsp, %rdi
callq 0x1154f
movq 0x1bbb4(%rip), %rdi     # 0x2cff0
movq %rsp, %rsi
callq 0x8210
movq %rax, %r15
movq %r14, %rdi
callq 0x10ff2
movl %eax, %ebp
movq 0x28(%rsp), %r12
leaq 0x60(%rsp), %rdi
movq %r14, %rsi
callq 0x10fdc
addl %ebp, %r12d
subl 0x68(%rsp), %r12d
incl %r12d
leaq 0x80(%rsp), %rdi
movl %r12d, %esi
callq 0x1154f
leaq 0x80(%rsp), %rsi
movq %r15, %rdi
callq 0x8210
leaq 0xc3a0(%rip), %rsi      # 0x1d835
movq %rax, %rdi
callq 0x8240
movq %rax, %rdi
movq %rbx, %rsi
callq 0x8210
movq %rax, %rdi
callq 0x8130
leaq 0x80(%rsp), %rdi
callq 0x8478
leaq 0x60(%rsp), %rdi
callq 0x8478
movq %rsp, %rdi
callq 0x8478
leaq 0x20(%rsp), %rdi
callq 0x8478
leaq 0x40(%rsp), %rdi
callq 0x8478
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x1151c
jmp 0x11507
jmp 0x11507
jmp 0x11507
jmp 0x11530
jmp 0x11530
movq %rax, %rbx
jmp 0x1153d
movq %rax, %rbx
jmp 0x11526
movq %rax, %rbx
leaq 0x80(%rsp), %rdi
callq 0x8478
leaq 0x60(%rsp), %rdi
callq 0x8478
movq %rsp, %rdi
callq 0x8478
jmp 0x11533
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
callq 0x8478
leaq 0x40(%rsp), %rdi
callq 0x8478
movq %rbx, %rdi
callq 0x8400
// File: /workspace/github_cpp_makefile_star2_O2/martinda3[P]Compiler/src/TCoutput.cpp
// Function: toyc::pad[abi:cxx11](int)
std::string pad(int n) {
        std::string s = "";
	    for (int i = 1; i <= n; i++) s += " ";
        // for (int i = 1; i <= n; i++) s += ".";   // For easy visiol debugging
        return s;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
leaq 0xcff8(%rip), %rsi      # 0x1e55a
leaq 0x7(%rsp), %rdx
callq 0xd770
xorl %r15d, %r15d
testl %ebp, %ebp
cmovgl %ebp, %r15d
leaq 0xbb77(%rip), %r14      # 0x1d0f3
subl $0x1, %r15d
jb 0x1158f
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8430
jmp 0x1157c
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x8478
movq %r14, %rdi
callq 0x8400
// File: /workspace/github_cpp_makefile_star2_O2/martinda3[P]Compiler/src/ASreadState.cpp
// Function: toyc::ASreadState::ASreadState(toyc::ASexpression**, int)
ASreadState::ASreadState(ASexpression* identifiers[], int num)
	{
		for (int i = 0; i < num; i++)
		{
			identifierList[i] = identifiers[i];
		}
		numIdentifiers = num;
		setType(READstate);
	}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x13250
leaq 0x188b8(%rip), %rax     # 0x2ac40
movq %rax, (%rbx)
xorl %eax, %eax
testl %ebp, %ebp
movl $0x0, %ecx
cmovgl %ebp, %ecx
cmpq %rax, %rcx
je 0x123aa
movq (%r14,%rax,8), %rdx
movq %rdx, 0x10(%rbx,%rax,8)
incq %rax
jmp 0x12397
movl %ebp, 0xfb0(%rbx)
pushq $0x7
popq %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x13262
nop