LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: martinda3[P]Compiler/src/ASstatement.cpp
// Function: toyc::ASstatement::toTypeString[abi:cxx11]()
std::string ASstatement::toTypeString()
	{
		std::string s;
		switch (type)
		{
			case EXPRstate:
				s = "EXPRstate";
				break;
			case BREAKstate:
				s = "BREAKstate";
				break;
			case BLOCKstate:
				s = "BLOCKstate";
				break;
			case IFstate:
				s = "IFstate";
				break;
			case NULLstate:
				s = "NULLstate";
				break;
			case RETURNstate:
				s = "RETURNstate";
				break;
			case WHILEstate:
				s = "WRITEstate";
				break;
			case READstate:
				s = "READstate";
				break;
			case WRITEstate:
				s = "WRITEstate";
				break;
			case NEWLINEstate:
				s = "NEWLINEstate";
				break;
			default:
				s = "error";
				break;
		}
		return s;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x9480
movq -0x38(%rbp), %rax
movl 0x8(%rax), %eax
movq %rax, -0x30(%rbp)
subq $0x9, %rax
ja 0x1ef73
movq -0x30(%rbp), %rax
leaq 0x14f24(%rip), %rcx     # 0x33da0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x48(%rbp), %rdi
leaq 0x14f4d(%rip), %rsi     # 0x33ddd
callq 0x9470
jmp 0x1ee97
jmp 0x1ef87
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x9658
jmp 0x1efa4
movq -0x48(%rbp), %rdi
leaq 0x14f26(%rip), %rsi     # 0x33de7
callq 0x9470
jmp 0x1eec8
jmp 0x1ef87
movq -0x48(%rbp), %rdi
leaq 0x14f1a(%rip), %rsi     # 0x33df2
callq 0x9470
jmp 0x1eedf
jmp 0x1ef87
movq -0x48(%rbp), %rdi
leaq 0x14f0e(%rip), %rsi     # 0x33dfd
callq 0x9470
jmp 0x1eef6
jmp 0x1ef87
movq -0x48(%rbp), %rdi
leaq 0x14eff(%rip), %rsi     # 0x33e05
callq 0x9470
jmp 0x1ef0d
jmp 0x1ef87
movq -0x48(%rbp), %rdi
leaq 0x14ef5(%rip), %rsi     # 0x33e0f
callq 0x9470
jmp 0x1ef21
jmp 0x1ef87
movq -0x48(%rbp), %rdi
leaq 0x14eed(%rip), %rsi     # 0x33e1b
callq 0x9470
jmp 0x1ef35
jmp 0x1ef87
movq -0x48(%rbp), %rdi
leaq 0x14ee4(%rip), %rsi     # 0x33e26
callq 0x9470
jmp 0x1ef49
jmp 0x1ef87
movq -0x48(%rbp), %rdi
leaq 0x14ec5(%rip), %rsi     # 0x33e1b
callq 0x9470
jmp 0x1ef5d
jmp 0x1ef87
movq -0x48(%rbp), %rdi
leaq 0x14ec6(%rip), %rsi     # 0x33e30
callq 0x9470
jmp 0x1ef71
jmp 0x1ef87
movq -0x48(%rbp), %rdi
leaq 0x1586d(%rip), %rsi     # 0x347eb
callq 0x9470
jmp 0x1ef85
jmp 0x1ef87
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x1ef9a
movq -0x48(%rbp), %rdi
callq 0x9658
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x95b0
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x143c0
movq -0x20(%rbp), %rax
leaq 0x23c85(%rip), %rcx     # 0x42c60
addq $0x10, %rcx
movq %rcx, (%rax)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x1f015
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
movslq -0x18(%rbp), %rdx
movq (%rcx,%rdx,8), %rdx
movslq -0x18(%rbp), %rcx
movq %rdx, 0x10(%rax,%rcx,8)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x1efe9
movq -0x20(%rbp), %rdi
movl -0x14(%rbp), %eax
movl %eax, 0xfb0(%rdi)
movl $0x1, %esi
callq 0x2d600
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x28(%rbp)
callq 0x203f0
movq -0x28(%rbp), %rax
leaq 0x238c1(%rip), %rcx     # 0x42c90
addq $0x10, %rcx
movq %rcx, (%rax)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x1f409
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq -0x20(%rbp), %rdx
movq (%rcx,%rdx,8), %rdx
movslq -0x20(%rbp), %rcx
movq %rdx, 0x10(%rax,%rcx,8)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x1f3dd
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, 0xfb0(%rdi)
movl -0x1c(%rbp), %eax
movl %eax, 0xfb8(%rdi)
xorl %esi, %esi
callq 0x20430
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rdi, -0x100(%rbp)
movq %rdi, %rax
movq %rax, -0xf8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xf0(%rbp)
leaq -0x50(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0x1bce0
movq -0xe8(%rbp), %rsi
leaq 0x1438b(%rip), %rdx     # 0x33e78
leaq -0x30(%rbp), %rdi
callq 0xcc00
jmp 0x1faf8
movq -0xf0(%rbp), %rdi
addq $0x18, %rdi
leaq -0x30(%rbp), %rsi
movq %rsi, -0x110(%rbp)
callq 0x9420
movq -0x110(%rbp), %rdi
callq 0x9658
leaq -0x50(%rbp), %rdi
callq 0x9658
callq 0x1bd10
movq -0xf0(%rbp), %rax
movq 0x10(%rax), %rsi
movq (%rsi), %rax
movq (%rax), %rax
leaq -0xa0(%rbp), %rdi
movq %rdi, -0x108(%rbp)
callq *%rax
movq -0x108(%rbp), %rsi
leaq 0x1448e(%rip), %rdx     # 0x33fea
leaq -0x80(%rbp), %rdi
callq 0xcc00
jmp 0x1fb67
movq -0xf0(%rbp), %rdi
addq $0x18, %rdi
leaq -0x80(%rbp), %rsi
callq 0x9450
jmp 0x1fb7d
leaq -0x80(%rbp), %rdi
callq 0x9658
leaq -0xa0(%rbp), %rdi
callq 0x9658
callq 0x1bd30
leaq -0xe0(%rbp), %rdi
movq %rdi, -0x118(%rbp)
callq 0x1bce0
movq -0x118(%rbp), %rsi
leaq 0x142f6(%rip), %rdx     # 0x33eae
leaq -0xc0(%rbp), %rdi
callq 0xcc00
jmp 0x1fbc6
movq -0xf0(%rbp), %rdi
addq $0x18, %rdi
leaq -0xc0(%rbp), %rsi
callq 0x9450
jmp 0x1fbdf
leaq -0xc0(%rbp), %rdi
callq 0x9658
leaq -0xe0(%rbp), %rdi
callq 0x9658
movq -0xf0(%rbp), %rsi
movq -0x100(%rbp), %rdi
addq $0x18, %rsi
callq 0x9170
movq -0xf8(%rbp), %rax
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x9658
jmp 0x1fc98
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x1fc58
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x9658
leaq -0xa0(%rbp), %rdi
callq 0x9658
jmp 0x1fc98
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x1fc8c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x9658
leaq -0xe0(%rbp), %rdi
callq 0x9658
movq -0x58(%rbp), %rdi
callq 0x95b0
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x48(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x9480
movq -0x38(%rbp), %rax
movl 0x8(%rax), %eax
movq %rax, -0x30(%rbp)
subq $0x5, %rax
ja 0x205ca
movq -0x30(%rbp), %rax
leaq 0x139d0(%rip), %rcx     # 0x33efc
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq -0x48(%rbp), %rdi
leaq 0x139ea(%rip), %rsi     # 0x33f2a
callq 0x9470
jmp 0x20547
jmp 0x205de
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x9658
jmp 0x205fb
movq -0x48(%rbp), %rdi
leaq 0x139c6(%rip), %rsi     # 0x33f37
callq 0x9470
jmp 0x20578
jmp 0x205de
movq -0x48(%rbp), %rdi
leaq 0x139bb(%rip), %rsi     # 0x33f40
callq 0x9470
jmp 0x2058c
jmp 0x205de
movq -0x48(%rbp), %rdi
leaq 0x139b1(%rip), %rsi     # 0x33f4a
callq 0x9470
jmp 0x205a0
jmp 0x205de
movq -0x48(%rbp), %rdi
leaq 0x139a5(%rip), %rsi     # 0x33f52
callq 0x9470
jmp 0x205b4
jmp 0x205de
movq -0x48(%rbp), %rdi
leaq 0x1399c(%rip), %rsi     # 0x33f5d
callq 0x9470
jmp 0x205c8
jmp 0x205de
movq -0x48(%rbp), %rdi
leaq 0x14216(%rip), %rsi     # 0x347eb
callq 0x9470
jmp 0x205dc
jmp 0x205de
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x205f1
movq -0x48(%rbp), %rdi
callq 0x9658
movq -0x40(%rbp), %rax
addq $0x50, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x95b0
nopw %cs:(%rax,%rax)
nop
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x1f4, 0xfa8(%rax)     # imm = 0x1F4
jl 0x207c0
movq 0x24855(%rip), %rdi     # 0x44ff0
leaq 0x137f8(%rip), %rsi     # 0x33f9a
callq 0x9340
movq %rax, %rdi
movq 0x247ff(%rip), %rsi     # 0x44fb0
callq 0x9380
movl $0x1, %edi
callq 0x9410
movq -0x18(%rbp), %rax
movq -0x10(%rbp), %rdx
movl 0xfa8(%rax), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, 0xfa8(%rax)
movslq %ecx, %rcx
movq %rdx, 0x8(%rax,%rcx,8)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x270, %rsp            # imm = 0x270
movq %rdx, -0x250(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
leaq -0x218(%rbp), %rdi
movq %rdi, -0x258(%rbp)
callq 0x9570
movq -0x258(%rbp), %rdi
movq -0x250(%rbp), %rsi
movl $0x10, %edx
callq 0x91a0
jmp 0x2085b
movl $0x0, -0x228(%rbp)
movl -0x228(%rbp), %eax
movl %eax, -0x260(%rbp)
movq -0x10(%rbp), %rdi
movq (%rdi), %rax
movq 0x10(%rax), %rax
callq *%rax
movl %eax, -0x25c(%rbp)
jmp 0x20886
movl -0x260(%rbp), %eax
movl -0x25c(%rbp), %ecx
cmpl %ecx, %eax
jge 0x20953
movq -0x10(%rbp), %rdi
movl -0x228(%rbp), %esi
movq (%rdi), %rax
movq 0x8(%rax), %rax
callq *%rax
movq %rax, -0x268(%rbp)
jmp 0x208b6
movq -0x268(%rbp), %rsi
movq (%rsi), %rax
movq (%rax), %rax
leaq -0x248(%rbp), %rdi
callq *%rax
jmp 0x208ce
leaq -0x218(%rbp), %rdi
leaq -0x248(%rbp), %rsi
callq 0x92f0
movq %rax, -0x270(%rbp)
jmp 0x208ea
movq -0x270(%rbp), %rdi
movq 0x246b8(%rip), %rsi     # 0x44fb0
callq 0x9380
jmp 0x208ff
leaq -0x248(%rbp), %rdi
callq 0x9658
movl -0x228(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x228(%rbp)
jmp 0x20865
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
jmp 0x20976
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
leaq -0x248(%rbp), %rdi
callq 0x9658
jmp 0x20976
leaq -0x218(%rbp), %rdi
callq 0x9490
jmp 0x20961
leaq -0x218(%rbp), %rdi
callq 0x94d0
addq $0x270, %rsp            # imm = 0x270
popq %rbp
retq
leaq -0x218(%rbp), %rdi
callq 0x94d0
movq -0x220(%rbp), %rdi
callq 0x95b0
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rsi, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
callq 0x20c70
movq -0x48(%rbp), %rdi
addq $0x8, %rdi
callq 0x20c90
movq -0x48(%rbp), %rdi
leaq 0x223d7(%rip), %rax     # 0x42e50
movq %rax, (%rdi)
leaq 0x223e5(%rip), %rax     # 0x42e68
movq %rax, 0x8(%rdi)
addq $0x10, %rdi
movq %rdi, -0x40(%rbp)
callq 0x9480
movq -0x40(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x9050
jmp 0x20aa3
xorl %eax, %eax
movl %eax, %edi
callq 0x9310
movq %rax, -0x28(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x9260
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rdi
callq 0x9160
movq -0x48(%rbp), %rdi
movq %rax, %rsi
addq $0x10, %rdi
callq 0x9470
jmp 0x20ad8
addq $0x50, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x9658
movq -0x18(%rbp), %rdi
callq 0x95b0
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x20c70
movq -0x38(%rbp), %rdi
addq $0x8, %rdi
callq 0x20c90
movq -0x38(%rbp), %rdi
leaq 0x2231f(%rip), %rax     # 0x42e50
movq %rax, (%rdi)
leaq 0x2232d(%rip), %rax     # 0x42e68
movq %rax, 0x8(%rdi)
addq $0x10, %rdi
movq %rdi, -0x30(%rbp)
callq 0x9480
movq -0x30(%rbp), %rdi
leaq 0x13b9d(%rip), %rsi     # 0x346f4
callq 0x9470
jmp 0x20b5e
xorl %eax, %eax
movl %eax, %edi
callq 0x9310
movq %rax, -0x20(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x9260
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rdi
callq 0x9160
movq -0x38(%rbp), %rdi
movq %rax, %rsi
addq $0x10, %rdi
callq 0x9470
jmp 0x20b93
movq -0x38(%rbp), %rdi
addq $0x10, %rdi
movq %rdi, -0x40(%rbp)
callq 0x9150
movq %rax, %rdi
leaq 0x1343b(%rip), %rsi     # 0x33fe9
callq 0x9090
movq -0x40(%rbp), %rdi
movq %rax, %rsi
movq $-0x1, %rdx
callq 0x90e0
jmp 0x20bc8
addq $0x40, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
callq 0x9658
movq -0x10(%rbp), %rdi
callq 0x95b0
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rsi, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x14, 0x2d0(%rax)
jne 0x2435d
leaq 0x1019f(%rip), %rdi     # 0x344eb
movb $0x0, %al
callq 0x9070
movl $0x1, %edi
callq 0x9410
movq -0x20(%rbp), %rsi
movq -0x18(%rbp), %rcx
movq %rcx, %rdi
addq $0x50, %rdi
movl 0x2d0(%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0x2d0(%rcx)
cltq
shlq $0x5, %rax
addq %rax, %rdi
callq 0x9050
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x78(%rbp)
movq %rdi, %rax
movq %rax, -0x88(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdx
movq %rdx, -0x80(%rbp)
movb $0x0, -0x11(%rbp)
addq $0x10, %rdx
leaq 0x10143(%rip), %rsi     # 0x3451b
leaq -0x38(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x13600
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
leaq 0xfb06(%rip), %rdx      # 0x33efa
callq 0xcc00
jmp 0x243fb
leaq -0x38(%rbp), %rdi
callq 0x9658
movq -0x80(%rbp), %rax
cmpl $0x0, 0x2d0(%rax)
je 0x2447a
movl $0x0, -0x48(%rbp)
movq -0x80(%rbp), %rcx
movl -0x48(%rbp), %eax
cmpl 0x2d0(%rcx), %eax
jge 0x24478
movq -0x78(%rbp), %rdi
movq -0x80(%rbp), %rax
movslq -0x48(%rbp), %rcx
shlq $0x5, %rcx
leaq 0x50(%rax,%rcx), %rsi
callq 0x9450
jmp 0x24443
jmp 0x24445
movl -0x48(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x48(%rbp)
jmp 0x24418
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x9658
jmp 0x244f1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x244e8
jmp 0x2447a
movq -0x80(%rbp), %rdx
addq $0x30, %rdx
leaq 0xfa25(%rip), %rsi      # 0x33eae
leaq -0x68(%rbp), %rdi
callq 0x13600
jmp 0x24494
movq -0x78(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x9450
jmp 0x244a3
leaq -0x68(%rbp), %rdi
callq 0x9658
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x244d8
jmp 0x244cf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x9658
jmp 0x244e8
movq -0x78(%rbp), %rdi
callq 0x9658
movq -0x88(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x9658
movq -0x40(%rbp), %rdi
callq 0x95b0
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xb0, %rsp
movq %rdi, -0xa8(%rbp)
movq %rdi, %rax
movq %rax, -0xa0(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x98(%rbp)
movb $0x0, -0x11(%rbp)
addq $0x10, %rsi
leaq 0xdac5(%rip), %rdx      # 0x33153
callq 0x1ad70
movl $0x0, -0x18(%rbp)
movq -0x98(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl 0x2b0(%rcx), %eax
jge 0x25723
movq -0x98(%rbp), %rax
movslq -0x18(%rbp), %rcx
shlq $0x5, %rcx
leaq 0x30(%rax,%rcx), %rsi
leaq 0xda8c(%rip), %rdx      # 0x33153
leaq -0x38(%rbp), %rdi
callq 0x1ad70
jmp 0x256d2
movq -0xa8(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x9450
jmp 0x256e4
leaq -0x38(%rbp), %rdi
callq 0x9658
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x2569a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x25849
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x9658
jmp 0x25849
movq -0x98(%rbp), %rsi
addq $0x540, %rsi            # imm = 0x540
leaq 0xe7c2(%rip), %rdx      # 0x33efa
leaq -0x68(%rbp), %rdi
callq 0x1ad70
jmp 0x25743
movq -0xa8(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x9450
jmp 0x25755
leaq -0x68(%rbp), %rdi
callq 0x9658
movl $0x0, -0x6c(%rbp)
movq -0x98(%rbp), %rcx
movl -0x6c(%rbp), %eax
cmpl 0x538(%rcx), %eax
jge 0x257c3
movq -0xa8(%rbp), %rdi
movq -0x98(%rbp), %rax
movslq -0x6c(%rbp), %rcx
shlq $0x5, %rcx
leaq 0x2b8(%rax,%rcx), %rsi
callq 0x9450
jmp 0x2579c
jmp 0x2579e
movl -0x6c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x6c(%rbp)
jmp 0x25765
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x9658
jmp 0x25849
movq -0x98(%rbp), %rdx
addq $0x560, %rdx            # imm = 0x560
leaq 0xe6d6(%rip), %rsi      # 0x33eae
leaq -0x90(%rbp), %rdi
callq 0x13600
jmp 0x257e6
movq -0xa8(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x9450
jmp 0x257fb
leaq -0x90(%rbp), %rdi
callq 0x9658
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x25839
jmp 0x2582d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x9658
jmp 0x25849
movq -0xa8(%rbp), %rdi
callq 0x9658
movq -0xa0(%rbp), %rax
addq $0xb0, %rsp
popq %rbp
retq
movq -0xa8(%rbp), %rdi
callq 0x9658
movq -0x40(%rbp), %rdi
callq 0x95b0
nop
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x60(%rbp)
movq %rdi, %rax
movq %rax, -0x58(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x50(%rbp)
movb $0x0, -0x11(%rbp)
addq $0x10, %rsi
leaq 0xd701(%rip), %rdx      # 0x33153
callq 0x1ad70
movl $0x0, -0x18(%rbp)
movq -0x50(%rbp), %rcx
movl -0x18(%rbp), %eax
cmpl 0x2d0(%rcx), %eax
jge 0x25ad8
movq -0x50(%rbp), %rax
movslq -0x18(%rbp), %rcx
shlq $0x5, %rcx
leaq 0x50(%rax,%rcx), %rsi
leaq 0xd6ce(%rip), %rdx      # 0x33153
leaq -0x38(%rbp), %rdi
callq 0x1ad70
jmp 0x25a90
movq -0x60(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x9450
jmp 0x25a9f
leaq -0x38(%rbp), %rdi
callq 0x9658
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x25a5e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x25b08
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x9658
jmp 0x25b08
movq -0x60(%rbp), %rdi
movq -0x50(%rbp), %rsi
addq $0x30, %rsi
callq 0x9450
jmp 0x25aeb
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x25afe
movq -0x60(%rbp), %rdi
callq 0x9658
movq -0x58(%rbp), %rax
addq $0x60, %rsp
popq %rbp
retq
movq -0x60(%rbp), %rdi
callq 0x9658
movq -0x40(%rbp), %rdi
callq 0x95b0
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
callq 0xc950
testb $0x1, %al
jne 0x2718f
jmp 0x271e2
movq -0x8(%rbp), %rdi
callq 0xcbe0
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x271c3
movq -0x20(%rbp), %rdi
leaq 0x1bb8b(%rip), %rsi     # 0x42d38
leaq 0x1ba04(%rip), %rdx     # 0x42bb8
xorl %eax, %eax
movl %eax, %ecx
callq 0x93e0
movq %rax, -0x28(%rbp)
jmp 0x271cb
xorl %eax, %eax
movq %rax, -0x28(%rbp)
jmp 0x271cb
movq -0x28(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0x2a000
jmp 0x271e4
jmp 0x271e4
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x1ff50
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x28(%rbp)
subl $0x1, %eax
je 0x272b7
jmp 0x27298
movl -0x28(%rbp), %eax
subl $0x2, %eax
je 0x27327
jmp 0x272a6
movl -0x28(%rbp), %eax
subl $0x3, %eax
je 0x27397
jmp 0x27401
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x10, %edi
callq 0x9350
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0x22910
jmp 0x272da
movq -0x30(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movq %rax, -0x40(%rbp)
je 0x272f6
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq (%rdi), %rax
callq *(%rax)
jmp 0x27459
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x10, %esi
callq 0x9360
jmp 0x2747c
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movl $0x10, %edi
callq 0x9350
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
callq 0x22de0
jmp 0x2734a
movq -0x48(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movq %rax, -0x58(%rbp)
je 0x27366
movq -0x48(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq (%rdi), %rax
callq *(%rax)
jmp 0x27459
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x10, %esi
callq 0x9360
jmp 0x2747c
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movl $0x10, %edi
callq 0x9350
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x60(%rbp)
callq 0x22510
jmp 0x273ba
movq -0x60(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movq %rax, -0x70(%rbp)
je 0x273d6
movq -0x60(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x70(%rbp)
movq -0x68(%rbp), %rdi
movq -0x70(%rbp), %rsi
movq (%rdi), %rax
callq *(%rax)
jmp 0x27459
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x10, %esi
callq 0x9360
jmp 0x2747c
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
movl $0x18, %edi
callq 0x9350
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movl -0x14(%rbp), %esi
callq 0x21a70
jmp 0x27427
movq -0x78(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movq %rax, -0x88(%rbp)
je 0x27449
movq -0x78(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x88(%rbp)
movq -0x80(%rbp), %rdi
movq -0x88(%rbp), %rsi
movq (%rdi), %rax
callq *(%rax)
addq $0x90, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x18, %esi
callq 0x9360
movq -0x20(%rbp), %rdi
callq 0x95b0
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x1ff50
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x28(%rbp)
subl $0x1, %eax
je 0x274d7
jmp 0x274b8
movl -0x28(%rbp), %eax
subl $0x2, %eax
je 0x27547
jmp 0x274c6
movl -0x28(%rbp), %eax
subl $0x3, %eax
je 0x275b7
jmp 0x27621
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x10, %edi
callq 0x9350
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0x24910
jmp 0x274fa
movq -0x30(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movq %rax, -0x40(%rbp)
je 0x27516
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq (%rdi), %rax
callq *(%rax)
jmp 0x27679
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x10, %esi
callq 0x9360
jmp 0x2769c
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movl $0x10, %edi
callq 0x9350
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
callq 0x231d0
jmp 0x2756a
movq -0x48(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movq %rax, -0x58(%rbp)
je 0x27586
movq -0x48(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq (%rdi), %rax
callq *(%rax)
jmp 0x27679
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x10, %esi
callq 0x9360
jmp 0x2769c
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movl $0x10, %edi
callq 0x9350
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x60(%rbp)
callq 0x21980
jmp 0x275da
movq -0x60(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movq %rax, -0x70(%rbp)
je 0x275f6
movq -0x60(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x70(%rbp)
movq -0x68(%rbp), %rdi
movq -0x70(%rbp), %rsi
movq (%rdi), %rax
callq *(%rax)
jmp 0x27679
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x10, %esi
callq 0x9360
jmp 0x2769c
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
movl $0x18, %edi
callq 0x9350
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movl -0x14(%rbp), %esi
callq 0x233b0
jmp 0x27647
movq -0x78(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movq %rax, -0x88(%rbp)
je 0x27669
movq -0x78(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x88(%rbp)
movq -0x80(%rbp), %rdi
movq -0x88(%rbp), %rsi
movq (%rdi), %rax
callq *(%rax)
addq $0x90, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x18, %esi
callq 0x9360
movq -0x20(%rbp), %rdi
callq 0x95b0
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x1ff50
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x28(%rbp)
subl $0x1, %eax
je 0x276f7
jmp 0x276d8
movl -0x28(%rbp), %eax
subl $0x2, %eax
je 0x27767
jmp 0x276e6
movl -0x28(%rbp), %eax
subl $0x3, %eax
je 0x277d7
jmp 0x27841
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x10, %edi
callq 0x9350
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0x21b80
jmp 0x2771a
movq -0x30(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movq %rax, -0x40(%rbp)
je 0x27736
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq (%rdi), %rax
callq *(%rax)
jmp 0x27899
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x10, %esi
callq 0x9360
jmp 0x278bc
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movl $0x10, %edi
callq 0x9350
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
callq 0x24530
jmp 0x2778a
movq -0x48(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movq %rax, -0x58(%rbp)
je 0x277a6
movq -0x48(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq (%rdi), %rax
callq *(%rax)
jmp 0x27899
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x10, %esi
callq 0x9360
jmp 0x278bc
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movl $0x10, %edi
callq 0x9350
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x60(%rbp)
callq 0x22420
jmp 0x277fa
movq -0x60(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movq %rax, -0x70(%rbp)
je 0x27816
movq -0x60(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x70(%rbp)
movq -0x68(%rbp), %rdi
movq -0x70(%rbp), %rsi
movq (%rdi), %rax
callq *(%rax)
jmp 0x27899
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x10, %esi
callq 0x9360
jmp 0x278bc
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
movl $0x18, %edi
callq 0x9350
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movl -0x14(%rbp), %esi
callq 0x22310
jmp 0x27867
movq -0x78(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movq %rax, -0x88(%rbp)
je 0x27889
movq -0x78(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x88(%rbp)
movq -0x80(%rbp), %rdi
movq -0x88(%rbp), %rsi
movq (%rdi), %rax
callq *(%rax)
addq $0x90, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x18, %esi
callq 0x9360
movq -0x20(%rbp), %rdi
callq 0x95b0
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x1ff50
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x28(%rbp)
subl $0x1, %eax
je 0x27917
jmp 0x278f8
movl -0x28(%rbp), %eax
subl $0x2, %eax
je 0x27987
jmp 0x27906
movl -0x28(%rbp), %eax
subl $0x3, %eax
je 0x279f7
jmp 0x27a61
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movl $0x10, %edi
callq 0x9350
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
callq 0x24820
jmp 0x2793a
movq -0x30(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movq %rax, -0x40(%rbp)
je 0x27956
movq -0x30(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x40(%rbp)
movq -0x38(%rbp), %rdi
movq -0x40(%rbp), %rsi
movq (%rdi), %rax
callq *(%rax)
jmp 0x27ab9
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x10, %esi
callq 0x9360
jmp 0x27adc
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
movl $0x10, %edi
callq 0x9350
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x48(%rbp)
callq 0x216c0
jmp 0x279aa
movq -0x48(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movq %rax, -0x58(%rbp)
je 0x279c6
movq -0x48(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x58(%rbp)
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rsi
movq (%rdi), %rax
callq *(%rax)
jmp 0x27ab9
movq -0x48(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x10, %esi
callq 0x9360
jmp 0x27adc
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
movl $0x10, %edi
callq 0x9350
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x60(%rbp)
callq 0x23990
jmp 0x27a1a
movq -0x60(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movq %rax, -0x70(%rbp)
je 0x27a36
movq -0x60(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x70(%rbp)
movq -0x68(%rbp), %rdi
movq -0x70(%rbp), %rsi
movq (%rdi), %rax
callq *(%rax)
jmp 0x27ab9
movq -0x60(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x10, %esi
callq 0x9360
jmp 0x27adc
movq -0x10(%rbp), %rax
movq %rax, -0x80(%rbp)
movl $0x18, %edi
callq 0x9350
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movl -0x14(%rbp), %esi
callq 0x23880
jmp 0x27a87
movq -0x78(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movq %rax, -0x88(%rbp)
je 0x27aa9
movq -0x78(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x88(%rbp)
movq -0x80(%rbp), %rdi
movq -0x88(%rbp), %rsi
movq (%rdi), %rax
callq *(%rax)
addq $0x90, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x18, %esi
callq 0x9360
movq -0x20(%rbp), %rdi
callq 0x95b0
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rsi, %rax
movq %rdi, %rsi
movq %rsi, -0x78(%rbp)
movq %rsi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x1be70
movq -0x70(%rbp), %rdi
leaq 0xc717(%rip), %rsi      # 0x347cc
callq 0x13710
movb %al, -0x61(%rbp)
jmp 0x280bf
leaq -0x30(%rbp), %rdi
callq 0x9658
movb -0x61(%rbp), %al
testb $0x1, %al
jne 0x280d4
jmp 0x2816d
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
movl $0x10, %edi
callq 0x9350
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x80(%rbp)
callq 0x22220
jmp 0x280fa
movq -0x80(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movq %rax, -0x90(%rbp)
je 0x2811c
movq -0x80(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x90(%rbp)
movq -0x88(%rbp), %rdi
movq -0x90(%rbp), %rsi
movq (%rdi), %rax
callq *(%rax)
jmp 0x2827e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x9658
jmp 0x28287
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
movl $0x10, %esi
callq 0x9360
jmp 0x28287
movq -0x78(%rbp), %rsi
leaq -0x60(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x1be70
movq -0xa0(%rbp), %rdi
leaq 0xc63f(%rip), %rsi      # 0x347ce
callq 0x13710
movb %al, -0x91(%rbp)
jmp 0x2819c
leaq -0x60(%rbp), %rdi
callq 0x9658
movb -0x91(%rbp), %al
testb $0x1, %al
jne 0x281b4
jmp 0x28250
movq -0x10(%rbp), %rax
movq %rax, -0xb0(%rbp)
movl $0x10, %edi
callq 0x9350
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0xa8(%rbp)
callq 0x22710
jmp 0x281dd
movq -0xa8(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movq %rax, -0xb8(%rbp)
je 0x28205
movq -0xa8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0xb8(%rbp)
movq -0xb0(%rbp), %rdi
movq -0xb8(%rbp), %rsi
movq (%rdi), %rax
callq *(%rax)
jmp 0x2827c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x9658
jmp 0x28287
movq -0xa8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
movl $0x10, %esi
callq 0x9360
jmp 0x28287
movq 0x1cd99(%rip), %rdi     # 0x44ff0
leaq 0xc572(%rip), %rsi      # 0x347d0
callq 0x9340
movq %rax, %rdi
movq 0x1cd43(%rip), %rsi     # 0x44fb0
callq 0x9380
movl $0x1, %edi
callq 0x9410
jmp 0x2827e
addq $0xc0, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x95b0
// File: 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
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rsi, %rax
movq %rdi, %rsi
movq %rsi, -0x78(%rbp)
movq %rsi, -0x8(%rbp)
movq %rax, -0x10(%rbp)
leaq -0x30(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x1be70
movq -0x70(%rbp), %rdi
leaq 0xc52c(%rip), %rsi      # 0x347f1
callq 0x13710
movb %al, -0x61(%rbp)
jmp 0x282cf
leaq -0x30(%rbp), %rdi
callq 0x9658
movb -0x61(%rbp), %al
testb $0x1, %al
jne 0x282e4
jmp 0x2837d
movq -0x10(%rbp), %rax
movq %rax, -0x88(%rbp)
movl $0x10, %edi
callq 0x9350
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x80(%rbp)
callq 0x23790
jmp 0x2830a
movq -0x80(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movq %rax, -0x90(%rbp)
je 0x2832c
movq -0x80(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x90(%rbp)
movq -0x88(%rbp), %rdi
movq -0x90(%rbp), %rsi
movq (%rdi), %rax
callq *(%rax)
jmp 0x2848e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x9658
jmp 0x28497
movq -0x80(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
movl $0x10, %esi
callq 0x9360
jmp 0x28497
movq -0x78(%rbp), %rsi
leaq -0x60(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x1be70
movq -0xa0(%rbp), %rdi
leaq 0xb4ce(%rip), %rsi      # 0x3386d
callq 0x13710
movb %al, -0x91(%rbp)
jmp 0x283ac
leaq -0x60(%rbp), %rdi
callq 0x9658
movb -0x91(%rbp), %al
testb $0x1, %al
jne 0x283c4
jmp 0x28460
movq -0x10(%rbp), %rax
movq %rax, -0xb0(%rbp)
movl $0x10, %edi
callq 0x9350
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0xa8(%rbp)
callq 0x29f10
jmp 0x283ed
movq -0xa8(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movq %rax, -0xb8(%rbp)
je 0x28415
movq -0xa8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0xb8(%rbp)
movq -0xb0(%rbp), %rdi
movq -0xb8(%rbp), %rsi
movq (%rdi), %rax
callq *(%rax)
jmp 0x2848c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x9658
jmp 0x28497
movq -0xa8(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
movl $0x10, %esi
callq 0x9360
jmp 0x28497
movq 0x1cb89(%rip), %rdi     # 0x44ff0
leaq 0xc385(%rip), %rsi      # 0x347f3
callq 0x9340
movq %rax, %rdi
movq 0x1cb33(%rip), %rsi     # 0x44fb0
callq 0x9380
movl $0x1, %edi
callq 0x9410
jmp 0x2848e
addq $0xc0, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x95b0
// File: 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 %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x8(%rbp)
leaq 0x19f3a(%rip), %rsi     # 0x455e0
leaq -0x28(%rbp), %rdi
callq 0x9170
leaq 0x19f6a(%rip), %rsi     # 0x45620
leaq -0x48(%rbp), %rdi
callq 0x9170
jmp 0x2b6c1
movq -0x8(%rbp), %rdx
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x2c0b0
jmp 0x2b6d4
leaq -0x48(%rbp), %rdi
callq 0x9658
leaq -0x28(%rbp), %rdi
callq 0x9658
movq -0x8(%rbp), %rax
movq %rax, -0xd0(%rbp)
movl $0x10, %edi
callq 0x9350
movq %rax, %rdi
movq %rdi, -0xc8(%rbp)
xorl %esi, %esi
movl $0x10, %edx
callq 0x91d0
movq -0xc8(%rbp), %rdi
callq 0x2d390
movq -0xc8(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movq %rax, -0xc0(%rbp)
je 0x2b745
movq -0xc8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0xc0(%rbp)
movq -0xd0(%rbp), %rdi
movq -0xc0(%rbp), %rsi
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
leaq 0x19e7e(%rip), %rsi     # 0x455e0
leaq -0x78(%rbp), %rdi
movq %rdi, -0xd8(%rbp)
callq 0x9170
movq -0xd8(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x2c3e0
jmp 0x2b784
leaq -0x78(%rbp), %rdi
callq 0x9658
leaq 0x19e6c(%rip), %rsi     # 0x45600
leaq -0x98(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0x9170
movq -0xe0(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x2c4c0
jmp 0x2b7b9
leaq -0x98(%rbp), %rdi
callq 0x9658
leaq 0x1a014(%rip), %rsi     # 0x457e0
leaq -0xb8(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0x9170
movq -0xe8(%rbp), %rdi
movq -0x8(%rbp), %rsi
callq 0x2c640
jmp 0x2b7f1
leaq -0xb8(%rbp), %rdi
callq 0x9658
movq -0x8(%rbp), %rax
movq %rax, -0x100(%rbp)
movl $0x10, %edi
callq 0x9350
movq %rax, %rdi
movq %rdi, -0xf8(%rbp)
xorl %esi, %esi
movl $0x10, %edx
callq 0x91d0
movq -0xf8(%rbp), %rdi
callq 0x2d390
movq -0xf8(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movq %rax, -0xf0(%rbp)
je 0x2b85c
movq -0xf8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0xf0(%rbp)
movq -0x100(%rbp), %rdi
movq -0xf0(%rbp), %rsi
movq (%rdi), %rax
callq *(%rax)
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x2b89b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x9658
leaq -0x28(%rbp), %rdi
callq 0x9658
jmp 0x2b8ef
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x9658
jmp 0x2b8ef
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x9658
jmp 0x2b8ef
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0xb8(%rbp), %rdi
callq 0x9658
movq -0x50(%rbp), %rdi
callq 0x95b0
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x2c720
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x2c057
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movq -0x18(%rbp), %rsi
callq 0x26460
movq -0x18(%rbp), %rax
movq %rax, -0x40(%rbp)
movl $0x10, %edi
callq 0x9350
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x38(%rbp)
callq 0x230e0
jmp 0x2c007
movq -0x38(%rbp), %rcx
xorl %eax, %eax
cmpq $0x0, %rcx
movq %rax, -0x48(%rbp)
je 0x2c023
movq -0x38(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x48(%rbp)
movq -0x40(%rbp), %rdi
movq -0x48(%rbp), %rsi
movq (%rdi), %rax
callq *(%rax)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x2bfc3
movq -0x38(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x10, %esi
callq 0x9360
jmp 0x2c0a7
movq -0x18(%rbp), %rax
movq %rax, -0x58(%rbp)
movl $0x30, %edi
callq 0x9350
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x50(%rbp)
callq 0x26000
jmp 0x2c07a
movq -0x50(%rbp), %rsi
movq -0x58(%rbp), %rdi
movq (%rdi), %rax
callq *(%rax)
addq $0x60, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
movl $0x30, %esi
callq 0x9360
movq -0x28(%rbp), %rdi
callq 0x95b0
// File: martinda3[P]Compiler/src/ASdefinition.cpp
// Function: toyc::ASdefinition::toTypeString[abi:cxx11]()
std::string ASdefinition::toTypeString()
	{
		std::string s;
		switch (type)
		{
			case FUNCdef:
				s = "FUNCdef";
				break;
			case VARdef:
				s = "VARdef";
				break;
			default:
				s = "error";
				break;
		}
		return s;
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x40(%rbp)
movq %rdi, %rax
movq %rax, -0x38(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
movb $0x0, -0x11(%rbp)
callq 0x9480
movq -0x30(%rbp), %rax
movl 0x8(%rax), %eax
movl %eax, -0x28(%rbp)
testl %eax, %eax
je 0x2d666
jmp 0x2d65c
movl -0x28(%rbp), %eax
subl $0x1, %eax
je 0x2d691
jmp 0x2d6a5
movq -0x40(%rbp), %rdi
leaq 0x7611(%rip), %rsi      # 0x34c82
callq 0x9470
jmp 0x2d678
jmp 0x2d6b9
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
callq 0x9658
jmp 0x2d6d6
movq -0x40(%rbp), %rdi
leaq 0x75ee(%rip), %rsi      # 0x34c8a
callq 0x9470
jmp 0x2d6a3
jmp 0x2d6b9
movq -0x40(%rbp), %rdi
leaq 0x713b(%rip), %rsi      # 0x347eb
callq 0x9470
jmp 0x2d6b7
jmp 0x2d6b9
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x2d6cc
movq -0x40(%rbp), %rdi
callq 0x9658
movq -0x38(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x95b0
nop
// File: martinda3[P]Compiler/src/ASexpr.cpp
// Function: toyc::ASexpr::ASexpr(toyc::ASoperator*, toyc::ASexpression*, toyc::ASexpression*)
ASexpr::ASexpr(ASoperator* opr, ASexpression* oper1, ASexpression* oper2)
	{
		oper = opr;
		op1 = oper1;
		op2 = oper2;
		setType(EXPRexpr);
	}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
callq 0x203f0
movq -0x38(%rbp), %rdi
leaq 0x17568(%rip), %rax     # 0x44c78
movq %rax, (%rdi)
addq $0x28, %rdi
movq %rdi, -0x40(%rbp)
callq 0x9480
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, 0x10(%rdi)
movq -0x18(%rbp), %rax
movq %rax, 0x18(%rdi)
movq -0x20(%rbp), %rax
movq %rax, 0x20(%rdi)
movl $0x1, %esi
callq 0x20430
jmp 0x2d748
addq $0x40, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x9658
movq -0x28(%rbp), %rdi
callq 0x95b0
nopl (%rax)