LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/martinda3[P]Compiler/src/ASwhileState.cpp
// Function: toyc::ASwhileState::toString[abi:cxx11]()
std::string ASwhileState::toString()
	{
		std::string s;
		s = spaces() + "whileStatement(\n";
		indent();
		s += op1->toString() + "\n" +
		     op2->toString() + "\n" +
		     spaces() +  ")";
		outdent();
		return s;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movq %rsp, %rdi
callq 0x11921
leaq 0xb1f8(%rip), %rdx      # 0x1db3b
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0xa06b
leaq 0x20(%rsp), %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x82d0
movq %r15, %rdi
callq 0x8478
movq %rsp, %rdi
callq 0x8478
callq 0x11935
movq 0x10(%r14), %rsi
movq (%rsi), %rax
leaq 0x80(%rsp), %rdi
callq *(%rax)
leaq 0xb4da(%rip), %rdx      # 0x1de67
leaq 0xa0(%rsp), %rdi
leaq 0x80(%rsp), %rsi
callq 0xa06b
movq 0x18(%r14), %rsi
movq (%rsi), %rax
leaq 0x60(%rsp), %rdi
callq *(%rax)
leaq 0xc0(%rsp), %rdi
leaq 0xa0(%rsp), %rsi
leaq 0x60(%rsp), %rdx
callq 0xa559
leaq 0xb496(%rip), %rdx      # 0x1de67
leaq 0xe0(%rsp), %rdi
leaq 0xc0(%rsp), %rsi
callq 0xa06b
leaq 0x40(%rsp), %rdi
callq 0x11921
movq %rsp, %rdi
leaq 0xe0(%rsp), %rsi
leaq 0x40(%rsp), %rdx
callq 0xa559
leaq 0xb319(%rip), %rdx      # 0x1dd25
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
callq 0xa06b
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
callq 0x8450
leaq 0x20(%rsp), %rdi
callq 0x8478
movq %rsp, %rdi
callq 0x8478
leaq 0x40(%rsp), %rdi
callq 0x8478
leaq 0xe0(%rsp), %rdi
callq 0x8478
leaq 0xc0(%rsp), %rdi
callq 0x8478
leaq 0x60(%rsp), %rdi
callq 0x8478
leaq 0xa0(%rsp), %rdi
callq 0x8478
leaq 0x80(%rsp), %rdi
callq 0x8478
callq 0x11942
movq %rbx, %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x8478
jmp 0x12aa7
movq %rax, %r14
movq %rsp, %rdi
callq 0x8478
jmp 0x12ab4
movq %rax, %r14
leaq 0x40(%rsp), %rdi
callq 0x8478
jmp 0x12ac3
movq %rax, %r14
leaq 0xe0(%rsp), %rdi
callq 0x8478
jmp 0x12ad5
movq %rax, %r14
leaq 0xc0(%rsp), %rdi
callq 0x8478
leaq 0x60(%rsp), %rdi
callq 0x8478
leaq 0xa0(%rsp), %rdi
callq 0x8478
leaq 0x80(%rsp), %rdi
callq 0x8478
jmp 0x12b26
movq %rax, %r14
jmp 0x12ae2
movq %rax, %r14
jmp 0x12aec
movq %rax, %r14
jmp 0x12af9
jmp 0x12b23
movq %rax, %r14
movq %rsp, %rdi
jmp 0x12b01
jmp 0x12b23
movq %rax, %r14
movq %rbx, %rdi
callq 0x8478
movq %r14, %rdi
callq 0x8400
// File: /workspace/github_cpp_makefile_star2_O2/martinda3[P]Compiler/src/ASwriteState.cpp
// Function: toyc::ASwriteState::ASwriteState(toyc::ASexpression**, int)
ASwriteState::ASwriteState(ASexpression* expressions[], int num)
	{
		for (int i = 0; i < num; i++)
		{
			expressionList[i] = expressions[i];

		}
		numExpressions = num;
		setType(WRITEstate);
	}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %rbx
callq 0x13250
leaq 0x17e44(%rip), %rax     # 0x2acd0
movq %rax, (%rbx)
xorl %eax, %eax
testl %ebp, %ebp
movl $0x0, %ecx
cmovgl %ebp, %ecx
cmpq %rax, %rcx
je 0x12eae
movq (%r14,%rax,8), %rdx
movq %rdx, 0x10(%rbx,%rax,8)
incq %rax
jmp 0x12e9b
movl %ebp, 0xfb0(%rbx)
pushq $0x8
popq %rsi
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x13262
nop
// File: /workspace/github_cpp_makefile_star2_O2/martinda3[P]Compiler/src/ASwriteState.cpp
// Function: toyc::ASwriteState::toString[abi:cxx11]()
std::string ASwriteState::toString()
	{
		if (numExpressions == 0)
		{
			return "error";
		}
		std::string str = "";
		str += (spaces() + "writeStatement(\n");
		indent();
		str +=(expressionList[0]->toString() + "\n");
		for (int i = 1; i < numExpressions; i++)
		{
			str += (expressionList[i]->toString());
		}
		outdent();
		str += spaces() + ")\n";
		return str;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
cmpl $0x0, 0xfb0(%rsi)
je 0x13013
movq %rsi, %r14
leaq 0xb65f(%rip), %rsi      # 0x1e55a
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0xd770
leaq 0x28(%rsp), %rdi
callq 0x11921
leaq 0xac7c(%rip), %rdx      # 0x1db95
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xa06b
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x8450
leaq 0x8(%rsp), %rdi
callq 0x8478
leaq 0x28(%rsp), %rdi
callq 0x8478
callq 0x11935
movq 0x10(%r14), %rsi
movq (%rsi), %rax
leaq 0x28(%rsp), %rdi
callq *(%rax)
leaq 0xaf04(%rip), %rdx      # 0x1de67
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xa06b
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x8450
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x8478
leaq 0x28(%rsp), %rdi
callq 0x8478
pushq $0x1
popq %r12
movslq 0xfb0(%r14), %rax
cmpq %rax, %r12
jge 0x12fcb
movq 0x10(%r14,%r12,8), %rsi
movq (%rsi), %rax
movq %r15, %rdi
callq *(%rax)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8450
movq %r15, %rdi
callq 0x8478
incq %r12
jmp 0x12f9a
callq 0x11942
leaq 0x28(%rsp), %rdi
callq 0x11921
leaq 0xa045(%rip), %rdx      # 0x1d026
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xa06b
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x8450
leaq 0x8(%rsp), %rdi
callq 0x8478
leaq 0x28(%rsp), %rdi
callq 0x8478
jmp 0x13027
leaq 0xb649(%rip), %rsi      # 0x1e663
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0xd770
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x13042
jmp 0x13051
jmp 0x1306e
jmp 0x13042
jmp 0x13051
jmp 0x1306e
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x8478
jmp 0x13054
movq %rax, %r14
leaq 0x28(%rsp), %rdi
jmp 0x13067
jmp 0x1306e
jmp 0x1306e
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x8478
jmp 0x13071
movq %rax, %r14
movq %rbx, %rdi
callq 0x8478
movq %r14, %rdi
callq 0x8400
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/martinda3[P]Compiler/src/ASprogram.cpp
// Function: toyc::ASprogram::toTypeString[abi:cxx11]()
std::string ASprogram::toTypeString()
	{
		std::string s;
		switch (type)
		{
			case PROGprog:
				s = "PROGprog";
				break;
			default:
				s = "error";
				break;
		}
		return s;
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
cmpl $0x0, 0x8(%rsi)
leaq 0xaafc(%rip), %rax      # 0x1dbea
leaq 0xb56e(%rip), %rsi      # 0x1e663
cmoveq %rax, %rsi
callq 0x8440
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
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/ASvarDef.cpp
// Function: toyc::ASvarDef::ASvarDef(toyc::AStype**, int)
ASvarDef::ASvarDef(AStype* identifiers[], int num)
	{
		for (int i = 0; i < num; i++)
		{
			identifierList[i] = identifiers[i];

		}
		numIdentifiers = num;
		setType(VARdef);
	}

// Assembly:
leaq 0x17a6d(%rip), %rax     # 0x2ad60
movq %rax, (%rdi)
xorl %eax, %eax
testl %edx, %edx
movl $0x0, %ecx
cmovgl %edx, %ecx
cmpq %rax, %rcx
je 0x13315
movq (%rsi,%rax,8), %r8
movq %r8, 0x10(%rdi,%rax,8)
incq %rax
jmp 0x13302
movl %edx, 0xfb0(%rdi)
pushq $0x1
popq %rsi
jmp 0x19b3c
nop
// File: /workspace/github_cpp_makefile_star2_O2/martinda3[P]Compiler/src/ASvarDef.cpp
// Function: toyc::ASvarDef::toString[abi:cxx11]()
std::string ASvarDef::toString()
	{
		if (numIdentifiers == 0)
		{
			return "error";
		}
		std::string str = "";
		str += (spaces() + "varDef(" + identifierList[0]->toString());
		for (int i = 1; i < numIdentifiers; i++)
		{
			str += (", " + identifierList[i]->toString());
		}
		str += ")";
		return str;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
cmpl $0x0, 0xfb0(%rsi)
je 0x1344d
movq %rsi, %r14
leaq 0xb1f9(%rip), %rsi      # 0x1e55a
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0xd770
leaq 0x68(%rsp), %rdi
callq 0x11921
leaq 0xa935(%rip), %rdx      # 0x1dcb4
leaq 0x28(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0xa06b
movq 0x10(%r14), %rsi
movq (%rsi), %rax
leaq 0x48(%rsp), %rdi
callq *(%rax)
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0x48(%rsp), %rdx
callq 0xa559
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x8450
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x8478
leaq 0x48(%rsp), %rdi
callq 0x8478
leaq 0x28(%rsp), %r12
movq %r12, %rdi
callq 0x8478
leaq 0x68(%rsp), %rdi
callq 0x8478
pushq $0x1
popq %rbp
leaq 0xa8c7(%rip), %r13      # 0x1dcbc
movslq 0xfb0(%r14), %rax
cmpq %rax, %rbp
jge 0x1343c
movq 0x10(%r14,%rbp,8), %rsi
movq (%rsi), %rax
movq %r12, %rdi
callq *(%rax)
movq %r15, %rdi
movq %r13, %rsi
movq %r12, %rdx
callq 0xdde6
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8450
movq %r15, %rdi
callq 0x8478
movq %r12, %rdi
callq 0x8478
incq %rbp
jmp 0x133f5
leaq 0xa8e2(%rip), %rsi      # 0x1dd25
movq %rbx, %rdi
callq 0x8430
jmp 0x13461
leaq 0xb20f(%rip), %rsi      # 0x1e663
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0xd770
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x134cf
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x8478
jmp 0x1348a
movq %rax, %r14
leaq 0x48(%rsp), %rdi
callq 0x8478
jmp 0x13499
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x8478
jmp 0x134a8
movq %rax, %r14
leaq 0x68(%rsp), %rdi
jmp 0x134c8
jmp 0x134cf
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x8478
jmp 0x134c3
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x8478
jmp 0x134d2
movq %rax, %r14
movq %rbx, %rdi
callq 0x8478
movq %r14, %rdi
callq 0x8400
nop
// File: /workspace/github_cpp_makefile_star2_O2/martinda3[P]Compiler/src/ASfuncCall.cpp
// Function: toyc::ASfuncCall::ASfuncCall(toyc::ASexpression*, toyc::ASexpression**, int)
ASfuncCall::ASfuncCall(ASexpression* identifier, ASexpression* expressions[], int num)
	{
		for (int i = 0; i < num; i++)
		{
			expressionList[i] = expressions[i];
			
		}
		id = identifier;
		numExpressions = num;
		setType(FUNCCALLexpr);
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r12
movq %rsi, %r15
movq %rdi, %r14
callq 0x13d4c
leaq 0x1788d(%rip), %rax     # 0x2ad90
movq %rax, (%r14)
xorl %eax, %eax
testl %ebx, %ebx
movl $0x0, %ecx
cmovgl %ebx, %ecx
cmpq %rax, %rcx
je 0x13525
movq (%r12,%rax,8), %rdx
movq %rdx, 0x10(%r14,%rax,8)
incq %rax
jmp 0x13512
movq %r15, 0xfb0(%r14)
movl %ebx, 0xfb8(%r14)
movq %r14, %rdi
xorl %esi, %esi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x13d5e
// File: /workspace/github_cpp_makefile_star2_O2/martinda3[P]Compiler/src/ASexprState.cpp
// Function: toyc::ASexprState::toString[abi:cxx11]()
std::string ASexprState::toString()
	{
		s = spaces() + "exprStatement(\n";
		indent();
		s+= op->toString() + "\n";
		outdent();
		s+= spaces() + ")";
		return s;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x11921
leaq 0xa436(%rip), %rdx      # 0x1dcef
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq 0xa06b
leaq 0x18(%r15), %r14
leaq 0x8(%rsp), %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x82d0
movq %r12, %rdi
callq 0x8478
leaq 0x28(%rsp), %rdi
callq 0x8478
callq 0x11935
movq 0x10(%r15), %rsi
movq (%rsi), %rax
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq *(%rax)
leaq 0xa55e(%rip), %rdx      # 0x1de67
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0xa06b
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x8450
leaq 0x8(%rsp), %rdi
callq 0x8478
leaq 0x28(%rsp), %rdi
callq 0x8478
callq 0x11942
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x11921
leaq 0xa3d5(%rip), %rdx      # 0x1dd25
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0xa06b
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x8450
leaq 0x8(%rsp), %rdi
callq 0x8478
leaq 0x28(%rsp), %rdi
callq 0x8478
movq %rbx, %rdi
movq %r14, %rsi
callq 0x82f0
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x1399c
jmp 0x139ad
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x8478
jmp 0x139b0
jmp 0x139ad
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x8478
movq %rbx, %rdi
callq 0x8400
// File: /workspace/github_cpp_makefile_star2_O2/martinda3[P]Compiler/src/TCsymbol.cpp
// Function: toyc::TCsymbol::toString[abi:cxx11]()
std::string TCsymbol::toString()
	{
		std::string str;
		switch (getType())
		{
			case VAR:       str = "var(" + getId() + ")";       str += std::to_string(offset);  break;
			case FUNC:      str = "Function(" + getId() + ")";  break;
            case OFFSET:    str = "OFFSET,";                    str += std::to_string(offset);  break;
			case NO_TYPE:   str = "NOTYPE(" + getId() + ")";    break;
			default:        str = "error";                      break;
		}
		return str;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movl 0x44(%rsi), %eax
cmpq $0x3, %rax
ja 0x13ce0
movq %rsi, %r14
leaq 0xa1ad(%rip), %rcx      # 0x1dd40
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
callq 0x82f0
leaq 0xa1a5(%rip), %rsi      # 0x1dd55
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0xdde6
leaq 0xa15f(%rip), %rdx      # 0x1dd25
movq %rsp, %rdi
leaq 0x40(%rsp), %rsi
callq 0xa06b
movq %rsp, %r15
movq %rbx, %rdi
movq %r15, %rsi
callq 0x82d0
movq %r15, %rdi
callq 0x8478
leaq 0x40(%rsp), %rdi
callq 0x8478
leaq 0x20(%rsp), %rdi
callq 0x8478
movl 0x40(%r14), %esi
movq %rsp, %rdi
callq 0x11076
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x8450
jmp 0x13c3c
leaq 0xa147(%rip), %rsi      # 0x1dd64
movq %rbx, %rdi
callq 0x8440
movl 0x40(%r14), %esi
movq %rsp, %rdi
callq 0x11076
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x8450
movq %rsp, %rdi
jmp 0x13cd9
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
callq 0x82f0
leaq 0xa114(%rip), %rsi      # 0x1dd6c
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0xdde6
leaq 0xa0b7(%rip), %rdx      # 0x1dd25
movq %rsp, %rdi
leaq 0x40(%rsp), %rsi
callq 0xa06b
jmp 0x13cb4
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
callq 0x82f0
leaq 0xa0c9(%rip), %rsi      # 0x1dd5a
leaq 0x40(%rsp), %rdi
leaq 0x20(%rsp), %rdx
callq 0xdde6
leaq 0xa07e(%rip), %rdx      # 0x1dd25
movq %rsp, %rdi
leaq 0x40(%rsp), %rsi
callq 0xa06b
movq %rsp, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x82d0
movq %r14, %rdi
callq 0x8478
leaq 0x40(%rsp), %rdi
callq 0x8478
leaq 0x20(%rsp), %rdi
callq 0x8478
jmp 0x13cef
leaq 0xa97c(%rip), %rsi      # 0x1e663
movq %rbx, %rdi
callq 0x8440
movq %rbx, %rax
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
jmp 0x13d13
jmp 0x13d36
jmp 0x13d04
jmp 0x13d04
movq %rax, %r14
leaq 0x40(%rsp), %rdi
callq 0x8478
jmp 0x13d22
movq %rax, %r14
movq %rsp, %rdi
jmp 0x13d27
jmp 0x13d1f
jmp 0x13d1f
movq %rax, %r14
leaq 0x20(%rsp), %rdi
callq 0x8478
jmp 0x13d39
jmp 0x13d36
jmp 0x13d36
jmp 0x13d36
jmp 0x13d36
movq %rax, %r14
movq %rbx, %rdi
callq 0x8478
movq %r14, %rdi
callq 0x8400
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/martinda3[P]Compiler/src/ASexpression.cpp
// Function: toyc::ASexpression::toTypeString[abi:cxx11]()
std::string ASexpression::toTypeString()
	{
		std::string s;
		switch (type)
		{
			case FUNCCALLexpr:	s = "FUNCCALLexpr";	break;
			case EXPRexpr:		s = "EXPRexpr";		break;
			case MINUSexpr:		s = "MINUSexpr";	break;
			case NOTexpr:		s = "NOTexpr";		break;
			case SIMPLEexpr:	s = "SIMPLEexpr";	break;
			case EMPTYexpr:		s = "EMPTYexpr";	break;
			default:			s = "error";		break;
		}
		return s;
	}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, (%rdi)
andq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
movl 0x8(%rsi), %eax
cmpq $0x6, %rax
jae 0x13db8
leaq 0xa01d(%rip), %rcx      # 0x1ddcc
movslq (%rcx,%rax,4), %rsi
addq %rcx, %rsi
jmp 0x13dbf
leaq 0xa8a4(%rip), %rsi      # 0x1e663
movq %rbx, %rdi
callq 0x8440
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rbx, %rdi
callq 0x8478
movq %r14, %rdi
callq 0x8400
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/martinda3[P]Compiler/src/JVM/JVMtargetCode.cpp
// Function: toyc::JVMtargetCode::add(toyc::CGlineOfCode*)
void JVMtargetCode::add(CGlineOfCode* l) {
    if(size >= MAXLINES) {
      std::cerr << "Error - too many JVM instructions" << std::endl;
      exit(EXIT_FAILURE);
    }
    code[size++] = (JVMlineOfCode *)l;
  }

// Assembly:
movslq 0xfa8(%rdi), %rax
cmpq $0x1f4, %rax            # imm = 0x1F4
jge 0x13e9c
leal 0x1(%rax), %ecx
movl %ecx, 0xfa8(%rdi)
movq %rsi, 0x8(%rdi,%rax,8)
retq
pushq %rax
movq 0x1914c(%rip), %rdi     # 0x2cff0
leaq 0x9f6c(%rip), %rsi      # 0x1de17
callq 0x8240
movq %rax, %rdi
callq 0x8130
pushq $0x1
popq %rdi
callq 0x82c0
// File: /workspace/github_cpp_makefile_star2_O2/martinda3[P]Compiler/src/JVM/JVMtargetCode.cpp
// Function: toyc::JVMtargetCode::writeCode(toyc::CGtargetCode*, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void JVMtargetCode::writeCode(CGtargetCode * code, std::string fname){
    std::ofstream out;
    out.open(fname);
    for(int i = 0; i < code->getSize(); i++)
      out << code->getLineOfCode(i)->toString() << std::endl;
    out.close();
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rdx, %r14
movq %rsi, %rbx
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x83d0
pushq $0x10
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x8120
xorl %ebp, %ebp
leaq 0x8(%rsp), %r14
leaq 0x28(%rsp), %r15
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
cmpl %eax, %ebp
jge 0x13f46
movq (%rbx), %rax
movq %rbx, %rdi
movl %ebp, %esi
callq *0x8(%rax)
movq (%rax), %rcx
movq %r14, %rdi
movq %rax, %rsi
callq *(%rcx)
movq %r15, %rdi
movq %r14, %rsi
callq 0x8210
movq %rax, %rdi
callq 0x8130
movq %r14, %rdi
callq 0x8478
incl %ebp
jmp 0x13f04
leaq 0x28(%rsp), %rdi
callq 0x8300
leaq 0x28(%rsp), %rdi
callq 0x8340
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x13f7b
jmp 0x13f7b
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x8478
jmp 0x13f7e
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x8340
movq %rbx, %rdi
callq 0x8400
// File: /workspace/github_cpp_makefile_star2_O2/martinda3[P]Compiler/src/JVM/meta/timeAndSourceComment.cpp
// Function: toyc::timeAndSourceComment::timeAndSourceComment(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
timeAndSourceComment::timeAndSourceComment(std::string s) {
    text = s;
    time_t _tm = time(NULL);
    struct tm *curtime = localtime(&_tm);
    text = asctime(curtime);
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x16f29(%rip), %rax     # 0x2aef0
movq %rax, (%rdi)
leaq 0x16f37(%rip), %rax     # 0x2af08
movq %rax, 0x8(%rdi)
leaq 0x10(%rdi), %rbx
leaq 0x20(%rdi), %rax
movq %rax, 0x10(%rdi)
andq $0x0, 0x18(%rdi)
movb $0x0, 0x20(%rdi)
movq %rbx, %rdi
callq 0x8160
xorl %edi, %edi
callq 0x8220
movq %rsp, %rdi
movq %rax, (%rdi)
callq 0x8190
movq %rax, %rdi
callq 0x80f0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x8440
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0x14021
movq %rax, %r14
movq %rbx, %rdi
callq 0x8478
movq %r14, %rdi
callq 0x8400
// File: /workspace/github_cpp_makefile_star2_O2/martinda3[P]Compiler/src/JVM/meta/timeAndSourceComment.cpp
// Function: toyc::timeAndSourceComment::timeAndSourceComment()
timeAndSourceComment::timeAndSourceComment() {
    text = "";
    time_t _tm = time(NULL);
    struct tm *curtime = localtime(&_tm);
    text = asctime(curtime); // has a newline at end ... grrrr. Remove it!
    text.erase(strcspn(text.c_str(),"\r\n"));
  }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
leaq 0x16eb1(%rip), %rax     # 0x2aef0
movq %rax, (%rdi)
leaq 0x16ebf(%rip), %rax     # 0x2af08
movq %rax, 0x8(%rdi)
leaq 0x10(%rdi), %rbx
leaq 0x20(%rdi), %rax
movq %rax, 0x10(%rdi)
andq $0x0, 0x18(%rdi)
movb $0x0, 0x20(%rdi)
leaq 0xa4f1(%rip), %rsi      # 0x1e55a
movq %rbx, %rdi
callq 0x8440
xorl %edi, %edi
callq 0x8220
movq %rsp, %rdi
movq %rax, (%rdi)
callq 0x8190
movq %rax, %rdi
callq 0x80f0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x8440
movq (%rbx), %rdi
leaq 0x9dc6(%rip), %rsi      # 0x1de66
callq 0x8050
pushq $-0x1
popq %rdx
movq %rbx, %rdi
movq %rax, %rsi
callq 0x8090
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0x140bd
movq %rax, %r14
movq %rbx, %rdi
callq 0x8478
movq %r14, %rdi
callq 0x8400
// File: /workspace/github_cpp_makefile_star2_O2/martinda3[P]Compiler/src/JVM/instruction/INVOKESTATIC.cpp
// Function: toyc::INVOKESTATIC::addArg(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void INVOKESTATIC::addArg(std::string arg) {
    if(numArgs==MAX_INVOKESTATIC_ARGS) {
      printf("INTERNAL ERROR: too many args for INVOKESTATIC\n");
      exit(EXIT_FAILURE);
    }
    args[numArgs++] = arg;
  }

// Assembly:
movslq 0x2d0(%rdi), %rax
cmpq $0x14, %rax
je 0x15836
leal 0x1(%rax), %ecx
movl %ecx, 0x2d0(%rdi)
shlq $0x5, %rax
addq %rax, %rdi
addq $0x50, %rdi
jmp 0x8160
pushq %rax
leaq 0x8b23(%rip), %rdi      # 0x1e361
callq 0x8360
pushq $0x1
popq %rdi
callq 0x82c0
nop
// File: /workspace/github_cpp_makefile_star2_O2/martinda3[P]Compiler/src/JVM/instruction/INVOKESTATIC.cpp
// Function: toyc::INVOKESTATIC::toString[abi:cxx11]()
std::string INVOKESTATIC::toString() {
    std::string s = "\tinvokestatic " + name + "(";
    if (numArgs != 0)
      for (int i=0; i<numArgs; i++)
        s += args[i];
    s += ")" + type;
    return s;
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsi), %rdx
leaq 0x8aea(%rip), %rsi      # 0x1e352
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xd7ab
leaq 0x84f6(%rip), %rdx      # 0x1dd72
movq %rbx, %rdi
movq %r15, %rsi
callq 0xa06b
leaq 0x8(%rsp), %rdi
callq 0x8478
movl 0x2d0(%r14), %eax
testl %eax, %eax
je 0x158c5
leaq 0x50(%r14), %r15
xorl %r12d, %r12d
cltq
cmpq %rax, %r12
jge 0x158c5
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8450
incq %r12
movl 0x2d0(%r14), %eax
addq $0x20, %r15
jmp 0x158a3
addq $0x30, %r14
leaq 0x8455(%rip), %rsi      # 0x1dd25
leaq 0x8(%rsp), %rdi
movq %r14, %rdx
callq 0xd7ab
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x8450
leaq 0x8(%rsp), %rdi
callq 0x8478
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x8478
jmp 0x15921
jmp 0x1591e
movq %rax, %r14
leaq 0x8(%rsp), %rdi
jmp 0x15924
movq %rax, %r14
movq %rbx, %rdi
callq 0x8478
movq %r14, %rdi
callq 0x8400
nop
// File: /workspace/github_cpp_makefile_star2_O2/martinda3[P]Compiler/src/JVM/directive/method.cpp
// Function: toyc::method::toString[abi:cxx11]()
std::string method::toString() {
    std::string s = directive + " ";
    for (int i=0; i<accessSize; i++) s += (accessSpecs[i] + " ");
    s += name + "(";
    for (int i=0; i<argsSize; i++) s += args[i];
    s += (")" + type);
    return s;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x10, %rsi
leaq 0x701c(%rip), %r15      # 0x1d0f3
movq %r15, %rdx
callq 0x110f1
leaq 0x30(%r14), %r12
xorl %ebp, %ebp
leaq 0x8(%rsp), %r13
movslq 0x2b0(%r14), %rax
cmpq %rax, %rbp
jge 0x16120
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x110f1
movq %rbx, %rdi
movq %r13, %rsi
callq 0x8450
movq %r13, %rdi
callq 0x8478
incq %rbp
addq $0x20, %r12
jmp 0x160ea
leaq 0x540(%r14), %rsi
leaq 0x7c44(%rip), %rdx      # 0x1dd72
leaq 0x8(%rsp), %rdi
callq 0x110f1
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x8450
leaq 0x8(%rsp), %rdi
callq 0x8478
leaq 0x2b8(%r14), %r15
xorl %r12d, %r12d
movslq 0x538(%r14), %rax
cmpq %rax, %r12
jge 0x16179
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8450
incq %r12
addq $0x20, %r15
jmp 0x16159
addq $0x560, %r14            # imm = 0x560
leaq 0x7b9e(%rip), %rsi      # 0x1dd25
leaq 0x8(%rsp), %rdi
movq %r14, %rdx
callq 0xd7ab
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x8450
leaq 0x8(%rsp), %rdi
callq 0x8478
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x161c7
jmp 0x161d6
jmp 0x161c7
jmp 0x161d6
jmp 0x161d6
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x8478
jmp 0x161d9
movq %rax, %r14
movq %rbx, %rdi
callq 0x8478
movq %r14, %rdi
callq 0x8400
nop
// File: /workspace/github_cpp_makefile_star2_O2/martinda3[P]Compiler/src/JVM/directive/class_.cpp
// Function: toyc::class_::toString[abi:cxx11]()
std::string class_::toString() {
    std::string s = directive + " ";
    for (int i=0; i<accessSize; i++) s += (accessSpecs[i] + " ");
    s += className;
    return s;
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
addq $0x10, %rsi
leaq 0x6de8(%rip), %r15      # 0x1d0f3
movq %r15, %rdx
callq 0x110f1
leaq 0x50(%r14), %r12
xorl %ebp, %ebp
leaq 0x8(%rsp), %r13
movslq 0x2d0(%r14), %rax
cmpq %rax, %rbp
jge 0x16354
movq %r13, %rdi
movq %r12, %rsi
movq %r15, %rdx
callq 0x110f1
movq %rbx, %rdi
movq %r13, %rsi
callq 0x8450
movq %r13, %rdi
callq 0x8478
incq %rbp
addq $0x20, %r12
jmp 0x1631e
addq $0x30, %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8450
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x16386
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x8478
jmp 0x16389
movq %rax, %r14
movq %rbx, %rdi
callq 0x8478
movq %r14, %rdi
callq 0x8400
nop
// File: /workspace/github_cpp_makefile_star2_O2/martinda3[P]Compiler/src/JVM/JVMgenerateStatement.cpp
// Function: toyc::JVMgenerateStatement::genStatement(toyc::ASdefinition*, toyc::JVMtargetCode*)
void JVMgenerateStatement::genStatement(ASdefinition *ast,JVMtargetCode *tc) {
      ASfuncDef *Functions = dynamic_cast<ASfuncDef*>(ast);

      int FunctionDeclarations = Functions->getNumVarDef();

      if (FunctionDeclarations < 2) { tc->add(new limit("stack",10)); }
      else { tc->add(new limit("stack",10 )); }

      for (int Function = 0 ; Function <  FunctionDeclarations; Function++) // Not sure if needed
      {
//          ASvarDef *VarInit = JVMgenerateStatement::ASvarDefinition(dynamic_cast<ASvarDef*>(Functions->getVarDef(Function)), tc);
//          AStype *step = dynamic_cast<AStype*>(VarInit->getIdentifier(Function));
//          std::cout << "  "<< step->getExpr()->getLexeme() << std::endl;
//          JVMgenUtils::gen_ISTORE(*symTable->getSym(symTable->find(step->getExpr()->getLexeme())),tc);
      }

      ASblockState *FunctionBlock = dynamic_cast<ASblockState*>(Functions->getStatement());
      JVMgenerateStatement::BlockStatement(FunctionBlock, tc);
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
leaq 0x142b4(%rip), %rsi     # 0x2abb8
leaq 0x14285(%rip), %rdx     # 0x2ab90
xorl %ecx, %ecx
callq 0x8290
movq %rax, %r15
movq %rax, %rdi
callq 0xd916
movl %eax, %ebp
pushq $0x58
popq %rdi
callq 0x8250
movq %rax, %r14
cmpl $0x1, %ebp
jg 0x1696c
leaq 0x7ce2(%rip), %rsi      # 0x1e618
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xd770
movb $0x1, %bpl
leaq 0x28(%rsp), %rsi
pushq $0xa
popq %rdx
movq %r14, %rdi
callq 0x16708
movq (%rbx), %rax
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r14, %rsi
callq *(%rax)
leaq 0x28(%rsp), %rdi
jmp 0x169a7
leaq 0x7ca5(%rip), %rsi      # 0x1e618
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0xd770
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
pushq $0xa
popq %rdx
movq %r14, %rdi
callq 0x16708
movq (%rbx), %rax
xorl %ebp, %ebp
movq %rbx, %rdi
movq %r14, %rsi
callq *(%rax)
leaq 0x8(%rsp), %rdi
callq 0x8478
movq %r15, %rdi
callq 0xddde
leaq 0x1437d(%rip), %rsi     # 0x2ad38
leaq 0x1630e(%rip), %rdx     # 0x2ccd0
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x8290
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16a18
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jmp 0x169e4
movq %rax, %rbx
jmp 0x16a05
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
jmp 0x169fb
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x8478
testb %bpl, %bpl
je 0x16a10
pushq $0x58
popq %rsi
movq %r14, %rdi
callq 0x8260
movq %rbx, %rdi
callq 0x8400
// File: /workspace/github_cpp_makefile_star2_O2/martinda3[P]Compiler/src/JVM/JVMgenerateStatement.cpp
// Function: toyc::JVMgenerateStatement::IfStatement(toyc::ASifState*, toyc::JVMtargetCode*)
void JVMgenerateStatement::IfStatement(ASifState *ThisIf,JVMtargetCode *tc) {
        ASexpr *expr_set; ASstatement *statement_set; ASblockState *FunctionBlock;
        if (!ThisIf->isBinary()){
            expr_set = dynamic_cast<ASexpr*>(ThisIf->getOp1());
            JVMgenerateExpression::genExpression(expr_set, tc);
            statement_set = dynamic_cast<ASstatement*>(ThisIf->getOp2());
            FunctionBlock = dynamic_cast<ASblockState*>(statement_set);
            JVMgenerateStatement::BlockStatement(FunctionBlock, tc);
        } else {
            expr_set = dynamic_cast<ASexpr*>(ThisIf->getOp1());
            JVMgenerateExpression::genExpression(expr_set, tc);
            statement_set = dynamic_cast<ASstatement*>(ThisIf->getOp2());
            FunctionBlock = dynamic_cast<ASblockState*>(statement_set);
            JVMgenerateStatement::BlockStatement(FunctionBlock, tc);
            statement_set = dynamic_cast<ASstatement*>(ThisIf->getOp3());
            FunctionBlock = dynamic_cast<ASblockState*>(statement_set);
            JVMgenerateStatement::BlockStatement(FunctionBlock, tc);
        }
    }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
callq 0xa544
movl %eax, %ebp
movq %r14, %rdi
callq 0xa548
testb %bpl, %bpl
je 0x16e5a
testq %rax, %rax
je 0x16e7c
leaq 0x13fe4(%rip), %rsi     # 0x2ae28
leaq 0x15e55(%rip), %rdx     # 0x2cca0
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x8290
movq %rax, %rdi
jmp 0x16e7e
testq %rax, %rax
je 0x16ebb
leaq 0x13fc2(%rip), %rsi     # 0x2ae28
leaq 0x15e33(%rip), %rdx     # 0x2cca0
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x8290
movq %rax, %rdi
jmp 0x16ebd
xorl %edi, %edi
movq %rbx, %rsi
callq 0x17f84
movq %r14, %rdi
callq 0xa54e
leaq 0x13ea3(%rip), %rsi     # 0x2ad38
leaq 0x15e34(%rip), %rdx     # 0x2ccd0
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x8290
movq %rax, %rdi
movq %rbx, %rsi
callq 0x16a18
movq %r14, %rdi
callq 0xa554
jmp 0x16ecd
xorl %edi, %edi
movq %rbx, %rsi
callq 0x17f84
movq %r14, %rdi
callq 0xa54e
leaq 0x13e64(%rip), %rsi     # 0x2ad38
leaq 0x15df5(%rip), %rdx     # 0x2ccd0
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x8290
movq %rax, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x16a18
// File: /workspace/github_cpp_makefile_star2_O2/martinda3[P]Compiler/src/JVM/JVMgenerateStatement.cpp
// Function: toyc::JVMgenerateStatement::ReturnStatement(toyc::ASreturnState*, toyc::JVMtargetCode*)
void JVMgenerateStatement::ReturnStatement(ASreturnState *ThisReturn,JVMtargetCode *tc) {
        ASsimpleExpr *var;
        if (ThisReturn->isSimple()){
            var = dynamic_cast<ASsimpleExpr*>(ThisReturn->getOp());
            JVMgenerateExpression::genExpression(var, tc);
        } else { }
    }

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
callq 0x9ef4
testb %al, %al
je 0x16f31
movq %r14, %rdi
callq 0xa066
testq %rax, %rax
je 0x16f39
leaq 0x13f0d(%rip), %rsi     # 0x2ae28
leaq 0x13d86(%rip), %rdx     # 0x2aca8
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x8290
movq %rax, %rdi
jmp 0x16f3b
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %edi, %edi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x17f84
// File: /workspace/github_cpp_makefile_star2_O2/martinda3[P]Compiler/src/JVM/JVMgenUtils.cpp
// Function: toyc::JVMgenUtils::gen_ISTORE(toyc::TCsymbol, toyc::JVMtargetCode*)
void JVMgenUtils::gen_ISTORE(TCsymbol id,JVMtargetCode *tc){
    int offset = id.getOffset();
    switch (offset) {
    case 1:  tc->add(new ISTORE_1()); break;
    case 2:  tc->add(new ISTORE_2()); break;
    case 3:  tc->add(new ISTORE_3()); break;
    default: tc->add(new ISTORE(offset)); 
    }

  }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
callq 0x13b34
cmpl $0x3, %eax
je 0x16fd7
movl %eax, %ebp
cmpl $0x2, %eax
je 0x16fc2
cmpl $0x1, %ebp
jne 0x16fec
pushq $0x10
popq %rdi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x14da0
jmp 0x17001
pushq $0x10
popq %rdi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x14f44
jmp 0x17001
pushq $0x10
popq %rdi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x14c08
jmp 0x17001
pushq $0x18
popq %rdi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
movl %ebp, %esi
callq 0x14774
addq $0x8, %r14
movq (%rbx), %rax
movq (%rax), %rax
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %rbp
jmpq *%rax
movq %rax, %rbx
pushq $0x18
jmp 0x17027
jmp 0x17022
jmp 0x17022
movq %rax, %rbx
pushq $0x10
popq %rsi
movq %r14, %rdi
callq 0x8260
movq %rbx, %rdi
callq 0x8400
// File: /workspace/github_cpp_makefile_star2_O2/martinda3[P]Compiler/src/JVM/JVMgenUtils.cpp
// Function: toyc::JVMgenUtils::gen_ILOAD(toyc::TCsymbol, toyc::JVMtargetCode*)
void JVMgenUtils::gen_ILOAD(TCsymbol id,JVMtargetCode *tc){ 
    int offset = id.getOffset();
    switch(offset){
    case 1:  tc->add(new ILOAD_1()); break;
    case 2:  tc->add(new ILOAD_2()); break;
    case 3:  tc->add(new ILOAD_3()); break;
    default: tc->add(new ILOAD(offset));
    }
  }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
callq 0x13b34
cmpl $0x3, %eax
je 0x1707f
movl %eax, %ebp
cmpl $0x2, %eax
je 0x1706a
cmpl $0x1, %ebp
jne 0x17094
pushq $0x10
popq %rdi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x15aa0
jmp 0x170a9
pushq $0x10
popq %rdi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x150d8
jmp 0x170a9
pushq $0x10
popq %rdi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x1472c
jmp 0x170a9
pushq $0x18
popq %rdi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
movl %ebp, %esi
callq 0x15168
addq $0x8, %r14
movq (%rbx), %rax
movq (%rax), %rax
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %rbp
jmpq *%rax
movq %rax, %rbx
pushq $0x18
jmp 0x170cf
jmp 0x170ca
jmp 0x170ca
movq %rax, %rbx
pushq $0x10
popq %rsi
movq %r14, %rdi
callq 0x8260
movq %rbx, %rdi
callq 0x8400
// File: /workspace/github_cpp_makefile_star2_O2/martinda3[P]Compiler/src/JVM/JVMgenUtils.cpp
// Function: toyc::JVMgenUtils::gen_ASTORE(toyc::TCsymbol, toyc::JVMtargetCode*)
void JVMgenUtils::gen_ASTORE(TCsymbol id,JVMtargetCode *tc){
    int offset = id.getOffset();
    switch (offset) {
    case 1:  tc->add(new ASTORE_1()); break;
    case 2:  tc->add(new ASTORE_2()); break;
    case 3:  tc->add(new ASTORE_3()); break;
    default: tc->add(new ASTORE(offset)); 
    }
  }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
callq 0x13b34
cmpl $0x3, %eax
je 0x17127
movl %eax, %ebp
cmpl $0x2, %eax
je 0x17112
cmpl $0x1, %ebp
jne 0x1713c
pushq $0x10
popq %rdi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x147f8
jmp 0x17151
pushq $0x10
popq %rdi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x15944
jmp 0x17151
pushq $0x10
popq %rdi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x14bc0
jmp 0x17151
pushq $0x18
popq %rdi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
movl %ebp, %esi
callq 0x14b3c
addq $0x8, %r14
movq (%rbx), %rax
movq (%rax), %rax
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %rbp
jmpq *%rax
movq %rax, %rbx
pushq $0x18
jmp 0x17177
jmp 0x17172
jmp 0x17172
movq %rax, %rbx
pushq $0x10
popq %rsi
movq %r14, %rdi
callq 0x8260
movq %rbx, %rdi
callq 0x8400
// File: /workspace/github_cpp_makefile_star2_O2/martinda3[P]Compiler/src/JVM/JVMgenUtils.cpp
// Function: toyc::JVMgenUtils::gen_ALOAD(toyc::TCsymbol, toyc::JVMtargetCode*)
void JVMgenUtils::gen_ALOAD(TCsymbol id,JVMtargetCode *tc){  
    int offset = id.getOffset();
    switch(offset){
    case 1:  tc->add(new ALOAD_1()); break;
    case 2:  tc->add(new ALOAD_2()); break;
    case 3:  tc->add(new ALOAD_3()); break;
    default: tc->add(new ALOAD(offset));
    }
  }

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
callq 0x13b34
cmpl $0x3, %eax
je 0x171cf
movl %eax, %ebp
cmpl $0x2, %eax
je 0x171ba
cmpl $0x1, %ebp
jne 0x171e4
pushq $0x10
popq %rdi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x15a58
jmp 0x171f9
pushq $0x10
popq %rdi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x145c8
jmp 0x171f9
pushq $0x10
popq %rdi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x15390
jmp 0x171f9
pushq $0x18
popq %rdi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
movl %ebp, %esi
callq 0x1530c
addq $0x8, %r14
movq (%rbx), %rax
movq (%rax), %rax
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %rbp
jmpq *%rax
movq %rax, %rbx
pushq $0x18
jmp 0x1721f
jmp 0x1721a
jmp 0x1721a
movq %rax, %rbx
pushq $0x10
popq %rsi
movq %r14, %rdi
callq 0x8260
movq %rbx, %rdi
callq 0x8400
// File: /workspace/github_cpp_makefile_star2_O2/martinda3[P]Compiler/src/JVM/JVMgenUtils.cpp
// Function: toyc::JVMgenUtils::gen_ICONST(int, toyc::JVMtargetCode*)
void JVMgenUtils::gen_ICONST(int n,JVMtargetCode *tc){ 	
    switch(n){
    case -1: tc->add(new ICONST_M1()); break;
    case 0:  tc->add(new ICONST_0());  break;
    case 1:  tc->add(new ICONST_1());  break;
    case 2:  tc->add(new ICONST_2());  break;
    case 3:  tc->add(new ICONST_3());  break;
    case 4:  tc->add(new ICONST_4());  break;
    case 5:  tc->add(new ICONST_5());  break;
    default:
      if (n >= -128 && n <= 127)
        tc->add(new BIPUSH(n));
      else if (n >= -32768 && n <= 32767)
        tc->add(new SIPUSH(n));
      else tc->add(new LDC(n));
    }
  }

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl %edi, %r15d
leal 0x1(%r15), %eax
cmpl $0x6, %eax
ja 0x172ae
leaq 0x73dd(%rip), %rcx      # 0x1e628
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
pushq $0x10
popq %rdi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x15120
jmp 0x1730c
pushq $0x10
popq %rdi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x15c7c
jmp 0x1730c
pushq $0x10
popq %rdi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x15a10
jmp 0x1730c
pushq $0x10
popq %rdi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x14aac
jmp 0x1730c
movsbl %r15b, %eax
cmpl %r15d, %eax
jne 0x17323
pushq $0x18
popq %rdi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
movl %r15d, %esi
callq 0x14f8c
jmp 0x1730c
pushq $0x10
popq %rdi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x1527c
jmp 0x1730c
pushq $0x10
popq %rdi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x15234
jmp 0x1730c
pushq $0x10
popq %rdi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x14eb4
addq $0x8, %r14
movq (%rbx), %rax
movq (%rax), %rax
movq %rbx, %rdi
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmpq *%rax
movswl %r15w, %eax
cmpl %r15d, %eax
jne 0x17344
pushq $0x18
popq %rdi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
movl %r15d, %esi
callq 0x15cc4
jmp 0x1730c
pushq $0x38
popq %rdi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
movl %r15d, %esi
callq 0x153d8
jmp 0x1730c
movq %rax, %rbx
pushq $0x38
jmp 0x1737d
jmp 0x17365
movq %rax, %rbx
pushq $0x18
jmp 0x1737d
jmp 0x17378
jmp 0x17378
jmp 0x17378
jmp 0x17378
jmp 0x17378
jmp 0x17378
movq %rax, %rbx
pushq $0x10
popq %rsi
movq %r14, %rdi
callq 0x8260
movq %rbx, %rdi
callq 0x8400
// File: /workspace/github_cpp_makefile_star2_O2/martinda3[P]Compiler/src/JVM/JVMgenUtils.cpp
// Function: toyc::JVMgenUtils::gen_ADDOP(toyc::TCtoken, toyc::JVMtargetCode*)
void JVMgenUtils::gen_ADDOP(TCtoken tok, JVMtargetCode *tc) {
    if (tok.getLexeme()=="+")
      tc->add(new IADD());
    else if (tok.getLexeme()=="-")
      tc->add(new ISUB());
    else { // shouldn't happen
      std::cerr << "Error: gen_ADDOP: internal error" << std::endl;
      exit(EXIT_FAILURE);
    }
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x119f4
leaq 0x728f(%rip), %rsi      # 0x1e644
movq %r15, %rdi
callq 0xd821
movl %eax, %ebp
movq %r15, %rdi
callq 0x8478
testb %bpl, %bpl
je 0x173e1
pushq $0x10
popq %rdi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x14af4
jmp 0x17422
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x119f4
leaq 0x724e(%rip), %rsi      # 0x1e646
movq %r15, %rdi
callq 0xd821
movl %eax, %ebp
movq %r15, %rdi
callq 0x8478
testb %bpl, %bpl
je 0x1743c
pushq $0x10
popq %rdi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x14cd4
addq $0x8, %r14
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *(%rax)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x15bad(%rip), %rdi     # 0x2cff0
leaq 0x71fe(%rip), %rsi      # 0x1e648
callq 0x8240
movq %rax, %rdi
callq 0x8130
pushq $0x1
popq %rdi
callq 0x82c0
jmp 0x17461
movq %rax, %rbx
pushq $0x10
popq %rsi
movq %r14, %rdi
callq 0x8260
movq %rbx, %rdi
callq 0x8400
nop
// File: /workspace/github_cpp_makefile_star2_O2/martinda3[P]Compiler/src/JVM/JVMgenUtils.cpp
// Function: toyc::JVMgenUtils::gen_MULOP(toyc::TCtoken, toyc::JVMtargetCode*)
void JVMgenUtils::gen_MULOP(TCtoken tok, JVMtargetCode *tc) {
    if (tok.getLexeme()=="*")
      tc->add(new IMUL());
    else if (tok.getLexeme()=="/")
      tc->add(new IDIV());
    else { // shouldn't happen
      std::cerr << "Error: gen_MULOP: internal error" << std::endl;
      exit(EXIT_FAILURE);
    }
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x119f4
leaq 0x71ca(%rip), %rsi      # 0x1e669
movq %r15, %rdi
callq 0xd821
movl %eax, %ebp
movq %r15, %rdi
callq 0x8478
testb %bpl, %bpl
je 0x174cf
pushq $0x10
popq %rdi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x152c4
addq $0x8, %r14
jmp 0x1751e
leaq 0x8(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x119f4
leaq 0x622b(%rip), %rsi      # 0x1d711
movq %r15, %rdi
callq 0xd821
movl %eax, %ebp
movq %r15, %rdi
callq 0x8478
testb %bpl, %bpl
je 0x17534
pushq $0x10
popq %rdi
callq 0x8250
leaq 0x8(%rax), %r14
leaq 0x156f0(%rip), %rcx     # 0x2cc00
movq %rcx, (%rax)
leaq 0x156fe(%rip), %rcx     # 0x2cc18
movq %rcx, 0x8(%rax)
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *(%rax)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq 0x15ab5(%rip), %rdi     # 0x2cff0
leaq 0x7129(%rip), %rsi      # 0x1e66b
callq 0x8240
movq %rax, %rdi
callq 0x8130
pushq $0x1
popq %rdi
callq 0x82c0
movq %rax, %rbx
pushq $0x10
popq %rsi
movq %r14, %rdi
callq 0x8260
movq %rbx, %rdi
callq 0x8400
nop
// File: /workspace/github_cpp_makefile_star2_O2/martinda3[P]Compiler/src/JVM/JVMgenerateProgram.cpp
// Function: toyc::JVMgenerateProgram::genIntro(toyc::JVMtargetCode*)
void JVMgenerateProgram::genIntro(JVMtargetCode *tc) {
    gen_intro_comments(inputFileName,targetFileName,tc);
    tc->add(new blankLine());
    gen_source_directive(inputFileName, tc);
    gen_class_directive(outputClassFileName, tc);
    gen_super_directive(ROOT_CLASS, tc);
    tc->add(new blankLine());
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
leaq 0x14938(%rip), %rsi     # 0x2d4e8
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x82f0
leaq 0x14964(%rip), %rsi     # 0x2d528
leaq 0x8(%rsp), %rdi
callq 0x82f0
leaq 0x28(%rsp), %r14
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
movq %rbx, %rdx
callq 0x19070
leaq 0x8(%rsp), %rdi
callq 0x8478
leaq 0x28(%rsp), %rdi
callq 0x8478
pushq $0x10
popq %rdi
callq 0x8250
leaq 0x8(%rax), %rsi
leaq 0x1234e(%rip), %r15     # 0x2af58
leaq 0x10(%r15), %r12
movq %r12, (%rax)
addq $0x28, %r15
movq %r15, 0x8(%rax)
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
leaq 0x148c0(%rip), %rsi     # 0x2d4e8
leaq 0x88(%rsp), %r14
movq %r14, %rdi
callq 0x82f0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x191c8
leaq 0x88(%rsp), %rdi
callq 0x8478
leaq 0x148b1(%rip), %rsi     # 0x2d508
leaq 0x68(%rsp), %r14
movq %r14, %rdi
callq 0x82f0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x19250
leaq 0x68(%rsp), %rdi
callq 0x8478
leaq 0x14a68(%rip), %rsi     # 0x2d6e8
leaq 0x48(%rsp), %r14
movq %r14, %rdi
callq 0x82f0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x19312
leaq 0x48(%rsp), %rdi
callq 0x8478
pushq $0x10
popq %rdi
callq 0x8250
leaq 0x8(%rax), %rsi
movq %r12, (%rax)
movq %r15, 0x8(%rax)
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x18ce1
jmp 0x18ce1
jmp 0x18ce1
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x8478
jmp 0x18ce4
movq %rax, %rbx
movq %r14, %rdi
callq 0x8478
movq %rbx, %rdi
callq 0x8400
// File: /workspace/github_cpp_makefile_star2_O2/martinda3[P]Compiler/src/JVM/JVMgenerateProgram.cpp
// Function: toyc::JVMgenerateProgram::genMainMethod(toyc::ASdefinition**, int, toyc::JVMtargetCode*)
void JVMgenerateProgram::genMainMethod(ASdefinition** statements,int num,JVMtargetCode* tc) {
    gen_main_header(tc);
//    tc->add(new line(LINE_COUNTER)); LINE_COUNTER++;    //  Bookmakr
    for (int i=0; i < num; i++) {
        JVMgenerateStatement::genStatement(statements[i],tc);
        tc->add(new RETURN());
    }
    tc->add(new end());
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %r14d
movq %rdi, %r15
movq %rdx, %rdi
callq 0x1939a
xorl %ebp, %ebp
testl %r14d, %r14d
cmovlel %ebp, %r14d
pushq $0x10
popq %r12
cmpq %rbp, %r14
je 0x1901f
movq (%r15,%rbp,8), %rdi
movq %rbx, %rsi
callq 0x168f0
movq %r12, %rdi
callq 0x8250
movq %rax, %r13
movq %rax, %rdi
callq 0x15090
addq $0x8, %r13
movq (%rbx), %rax
movq %rbx, %rdi
movq %r13, %rsi
callq *(%rax)
incq %rbp
jmp 0x18fe7
pushq $0x30
popq %rdi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x16684
movq (%rbx), %rax
movq (%rax), %rax
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *%rax
movq %rax, %rbx
pushq $0x30
popq %rsi
movq %r14, %rdi
jmp 0x19062
movq %rax, %rbx
pushq $0x10
popq %rsi
movq %r13, %rdi
callq 0x8260
movq %rbx, %rdi
callq 0x8400
nop
// File: /workspace/github_cpp_makefile_star2_O2/martinda3[P]Compiler/src/JVM/JVMgenerateProgram.cpp
// Function: toyc::JVMgenerateProgram::gen_intro_comments(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, toyc::JVMtargetCode*)
void JVMgenerateProgram::gen_intro_comments(std::string s, std::string t, JVMtargetCode *tc) {
    tc->add(new blankComment());
    tc->add(new sourceFileComment(s));
    tc->add(new targetFileComment(t));
    tc->add(new timeAndSourceComment());
    tc->add(new blankComment());
  }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
pushq $0x10
popq %rdi
callq 0x8250
leaq 0x8(%rax), %rsi
leaq 0x1205e(%rip), %r13     # 0x2b0f8
leaq 0x10(%r13), %rbp
movq %rbp, (%rax)
addq $0x28, %r13
movq %r13, 0x8(%rax)
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
pushq $0x30
popq %rdi
callq 0x8250
movq %rax, %r14
leaq 0x28(%rsp), %rdi
movq %r12, %rsi
callq 0x82f0
movb $0x1, %r12b
leaq 0x28(%rsp), %rsi
movq %r14, %rdi
callq 0x142b0
movq %r14, %rsi
addq $0x8, %rsi
movq (%rbx), %rax
xorl %r12d, %r12d
movq %rbx, %rdi
callq *(%rax)
leaq 0x28(%rsp), %rdi
callq 0x8478
pushq $0x30
popq %rdi
callq 0x8250
movq %rax, %r14
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x82f0
movb $0x1, %r15b
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x1412c
movq %r14, %rsi
addq $0x8, %rsi
movq (%rbx), %rax
xorl %r15d, %r15d
movq %rbx, %rdi
callq *(%rax)
leaq 0x8(%rsp), %rdi
callq 0x8478
pushq $0x30
popq %rdi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x14034
addq $0x8, %r14
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *(%rax)
pushq $0x10
popq %rdi
callq 0x8250
leaq 0x8(%rax), %rsi
movq %rbp, (%rax)
movq %r13, 0x8(%rax)
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x19189
jmp 0x19189
movq %rax, %rbx
jmp 0x191b4
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x8478
testb %r15b, %r15b
jne 0x191b4
jmp 0x191bf
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x8478
testb %r12b, %r12b
je 0x191bf
pushq $0x30
popq %rsi
movq %r14, %rdi
callq 0x8260
movq %rbx, %rdi
callq 0x8400
nop