LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/martinda3[P]Compiler/src/TCparser.cpp
// Function: toyc::TCparser::NewLineStatement()
ASstatement* TCparser::NewLineStatement() // WIP
	{
		// NewLineStatement --> NEWLINE SEMICOLON
		enteringDEBUG("NewLine Statement");
		accept(NEWLINE);
		exitingDEBUG("NewLine Statement");
		accept(SEMICOLON);
		return new ASnewLineState();
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1bb73(%rip), %rsi     # 0x2a363
leaq 0x1bb7d(%rip), %rdx     # 0x2a374
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0xfc42
movq %r14, %rdi
callq 0xbac6
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0xe823
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x8260
movq %rbx, %rdi
movl $0xf, %esi
callq 0xc558
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1bb23(%rip), %rsi     # 0x2a363
leaq 0x1bb2d(%rip), %rdx     # 0x2a374
movq %rsp, %r14
movq %r14, %rdi
callq 0xfc42
movq %r14, %rdi
callq 0xbd28
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xe870
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x8260
movq %rbx, %rdi
movl $0x27, %esi
callq 0xc558
movl $0x10, %edi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x1b65c
movq %r14, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x10, %esi
movq %r14, %rdi
jmp 0xe8d4
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xe8d9
movq 0x10(%rsp), %rsi
jmp 0xe8d1
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0xe8d9
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x8260
movq %rbx, %rdi
callq 0x8420
// File: /workspace/github_cpp_makefile_star2_O1/martinda3[P]Compiler/src/TCparser.cpp
// Function: toyc::enter_special_id(toyc::TCsymTable*, toyc::tokens)
static void enter_special_id(TCsymTable *st,tokens type) {
	    int offffset;
        TCsymbol *sym = new TCsymbol();
        sym->setType(OFFSET);
        sym->setId((type==READ)?"System.in":"System.out");
        offffset = _nextOffset;
        sym->setOffset(offffset);
        sym->getNextOffset();
        st->add(sym);
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %esi, %ebp
movq %rdi, %r14
movl $0x48, %edi
callq 0x8250
movq %rax, %rbx
movq %rax, %rdi
callq 0x1b730
movq %rbx, %rdi
movl $0x2, %esi
callq 0x1b846
xorl %eax, %eax
cmpl $0x7, %ebp
sete %al
leaq 0x1bb84(%rip), %rcx     # 0x2a4a7
leaq 0x1bb87(%rip), %rsi     # 0x2a4b1
cmoveq %rcx, %rsi
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
negq %rax
leaq (%rsi,%rax), %rdx
addq $0xa, %rdx
movq %rsp, %r15
movq %r15, %rdi
callq 0xfc42
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1b83c
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0xe96f
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x8260
leaq 0x2b8ee(%rip), %rax     # 0x3a264
movl (%rax), %esi
movq %rbx, %rdi
callq 0x1b89c
movq %rbx, %rdi
callq 0x1b8a0
movq %r14, %rdi
movq %rbx, %rsi
callq 0x28820
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0xe9c6
movq 0x10(%rsp), %rsi
incq %rsi
jmp 0xe9c1
movq %rax, %r14
movl $0x48, %esi
movq %rbx, %rdi
callq 0x8260
movq %r14, %rdi
callq 0x8420
// File: /workspace/github_cpp_makefile_star2_O1/martinda3[P]Compiler/src/TCparser.cpp
// Function: toyc::TCparser::FunctionCall()
ASexpression* TCparser::FunctionCall() // WIP
	{
		// FunctionCall -- > LPAREN ActualParameters RPAREN
		enteringDEBUG("Function Call");
		ASexpression* operand = NULL;
		accept(LPAREN);
		try { operand = ActualParameters(); }
		catch (int t) { operand = new ASexpression(); }
		accept(RPAREN);
		exitingDEBUG("Function Call");
		return operand;
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x1a9dd(%rip), %rsi     # 0x2a46a
leaq 0x1a9e3(%rip), %rdx     # 0x2a477
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0xfc42
movq %r14, %rdi
callq 0xbac6
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0xfac0
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x8260
movq %rbx, %rdi
movl $0x1e, %esi
callq 0xc558
movq %rbx, %rdi
callq 0xe9ce
movq %rax, %r14
movq %rbx, %rdi
movl $0x1f, %esi
callq 0xc558
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x1a974(%rip), %rsi     # 0x2a46a
leaq 0x1a97a(%rip), %rdx     # 0x2a477
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xfc42
movq %rbx, %rdi
callq 0xbd28
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xfb29
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x8260
movq %r14, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r15
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xfbb1
movq 0x18(%rsp), %rsi
jmp 0xfba9
movq %rax, %r15
cmpl $0x1, %edx
jne 0xfbb1
movq %r15, %rdi
callq 0x80e0
movl $0x10, %edi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x1be54
callq 0x83d0
jmp 0xfad8
movq %rax, %r15
movl $0x10, %esi
movq %r14, %rdi
callq 0x8260
jmp 0xfb90
movq %rax, %r15
callq 0x83d0
jmp 0xfbb1
movq %rax, %r15
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0xfbb1
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x8260
movq %r15, %rdi
callq 0x8420
// File: /workspace/github_cpp_makefile_star2_O1/martinda3[P]Compiler/src/ASfuncDef.cpp
// Function: toyc::ASfuncDef::ASfuncDef(toyc::AStype*, toyc::ASdefinition**, int, toyc::ASstatement*)
ASfuncDef::ASfuncDef(AStype* id, ASdefinition* varDef[], int num, ASstatement* s)
	{
		identifier = id;
		for (int i = 0; i < num; i++)
		{
			varDefList[i] = varDef[i];
		}
		numVarDef = num;
		statement = s;
		setType(FUNCdef);
	}

// Assembly:
leaq 0x27e3d(%rip), %rax     # 0x37b18
movq %rax, (%rdi)
movq %rsi, 0x10(%rdi)
testl %ecx, %ecx
jle 0xfcfb
movl %ecx, %eax
xorl %esi, %esi
movq (%rdx,%rsi,8), %r9
movq %r9, 0x18(%rdi,%rsi,8)
incq %rsi
cmpq %rsi, %rax
jne 0xfcea
movl %ecx, 0xfb8(%rdi)
movq %r8, 0xfc0(%rdi)
xorl %esi, %esi
jmp 0x24dc4
nop
// File: /workspace/github_cpp_makefile_star2_O1/martinda3[P]Compiler/src/TCoutput.cpp
// Function: toyc::pad[abi:cxx11](int)
std::string pad(int n) {
        std::string s = "";
	    for (int i = 1; i <= n; i++) s += " ";
        // for (int i = 1; i <= n; i++) s += ".";   // For easy visiol debugging
        return s;
    }

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
leaq 0x14437(%rip), %rdx     # 0x2b621
movq %rdx, %rsi
callq 0xfc42
testl %ebp, %ebp
jle 0x1720c
leaq 0x12f22(%rip), %r14     # 0x2a11f
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8460
decl %ebp
jne 0x171fd
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x17230
movq (%r15), %rsi
incq %rsi
callq 0x8260
movq %r14, %rdi
callq 0x8420
// File: /workspace/github_cpp_makefile_star2_O1/martinda3[P]Compiler/src/ASreadState.cpp
// Function: toyc::ASreadState::ASreadState(toyc::ASexpression**, int)
ASreadState::ASreadState(ASexpression* identifiers[], int num)
	{
		for (int i = 0; i < num; i++)
		{
			identifierList[i] = identifiers[i];
		}
		numIdentifiers = num;
		setType(READstate);
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
callq 0x1a7e4
leaq 0x1f72b(%rip), %rax     # 0x37bd0
movq %rax, (%r14)
testl %ebx, %ebx
jle 0x184c1
movl %ebx, %eax
xorl %ecx, %ecx
movq (%r15,%rcx,8), %rdx
movq %rdx, 0x10(%r14,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x184b0
movl %ebx, 0xfb0(%r14)
movq %r14, %rdi
movl $0x7, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x1a7f6
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
callq 0x1a7e4
leaq 0x1dbbb(%rip), %rax     # 0x37c60
movq %rax, (%r14)
testl %ebx, %ebx
jle 0x1a0c1
movl %ebx, %eax
xorl %ecx, %ecx
movq (%r15,%rcx,8), %rdx
movq %rdx, 0x10(%r14,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x1a0b0
movl %ebx, 0xfb0(%r14)
movq %r14, %rdi
movl $0x8, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x1a7f6
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
xorl %eax, %eax
cmpl $0x0, 0x8(%rsi)
sete %al
leaq 0x10738(%rip), %rdx     # 0x2abe3
leaq 0x11279(%rip), %rcx     # 0x2b72b
cmoveq %rdx, %rcx
leaq (%rax,%rax,2), %r8
addq $0x5, %r8
xorl %esi, %esi
xorl %edx, %edx
callq 0x8390
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x1a4e6
movq (%r15), %rsi
incq %rsi
callq 0x8260
movq %r14, %rdi
callq 0x8420
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1d449(%rip), %rax     # 0x37cf0
movq %rax, (%rdi)
testl %edx, %edx
jle 0x1a8c3
movl %edx, %eax
xorl %ecx, %ecx
movq (%rsi,%rcx,8), %r8
movq %r8, 0x10(%rdi,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x1a8b2
movl %edx, 0xfb0(%rdi)
movl $0x1, %esi
jmp 0x24dc4
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1be54
leaq 0x1d059(%rip), %rax     # 0x37d20
movq %rax, (%r14)
testl %ebx, %ebx
jle 0x1ace3
movl %ebx, %eax
xorl %ecx, %ecx
movq (%r12,%rcx,8), %rdx
movq %rdx, 0x10(%r14,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x1acd2
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 0x1be66
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1bfc8
leal 0x1(%rax), %ecx
movl %ecx, 0xfa8(%rdi)
movq %rsi, 0x8(%rdi,%rax,8)
retq
pushq %rax
movq 0x1e020(%rip), %rdi     # 0x39ff0
leaq 0xeebc(%rip), %rsi      # 0x2ae93
callq 0x8240
movq %rax, %rdi
callq 0x8120
movl $0x1, %edi
callq 0x82e0
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0x228, %rsp            # imm = 0x228
movq %rdx, %r14
movq %rsi, %rbx
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x83e0
movq %r15, %rdi
movq %r14, %rsi
movl $0x10, %edx
callq 0x8110
xorl %ebp, %ebp
leaq 0x18(%rsp), %r13
leaq 0x8(%rsp), %r14
leaq 0x28(%rsp), %r15
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x10(%rax)
cmpl %eax, %ebp
jge 0x1c0b7
movq (%rbx), %rax
movq %rbx, %rdi
movl %ebp, %esi
callq *0x8(%rax)
movq (%rax), %rcx
movq %r14, %rdi
movq %rax, %rsi
callq *(%rcx)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %r15, %rdi
callq 0x82c0
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x8230
movsbl %al, %esi
movq %r12, %rdi
callq 0x8030
movq %rax, %rdi
callq 0x8170
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x1c0b3
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x8260
incl %ebp
jmp 0x1c03d
leaq 0x28(%rsp), %rdi
callq 0x8310
movq 0x1df00(%rip), %rax     # 0x39fc8
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq 0x30(%rsp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, 0x28(%rsp,%rcx)
callq 0x81e0
leaq 0x120(%rsp), %rdi
callq 0x80c0
addq $0x228, %rsp            # imm = 0x228
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1c109
jmp 0x1c109
movq %rax, %rbx
jmp 0x1c128
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x1c128
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x8260
leaq 0x28(%rsp), %rdi
callq 0x8350
movq %rbx, %rdi
callq 0x8420
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r14
leaq 0x1bd0a(%rip), %rax     # 0x37e80
movq %rax, (%rdi)
leaq 0x1bd18(%rip), %rax     # 0x37e98
movq %rax, 0x8(%rdi)
leaq 0x10(%rdi), %rbx
leaq 0x20(%rdi), %r12
movq %r12, 0x10(%rdi)
movq $0x0, 0x18(%rdi)
movb $0x0, 0x20(%rdi)
movq %rbx, %rdi
callq 0x8150
xorl %edi, %edi
callq 0x8220
movq %rsp, %rdi
movq %rax, (%rdi)
callq 0x81a0
movq %rax, %rdi
callq 0x80f0
movq %rax, %r15
movq 0x18(%r14), %r14
movq %rax, %rdi
callq 0x8100
movq %rbx, %rdi
xorl %esi, %esi
movq %r14, %rdx
movq %r15, %rcx
movq %rax, %r8
callq 0x8390
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0x1c1ee
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x1c205
movq (%r12), %rsi
incq %rsi
callq 0x8260
movq %r14, %rdi
callq 0x8420
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %r14
leaq 0x1bc5b(%rip), %rax     # 0x37e80
movq %rax, (%rdi)
leaq 0x1bc69(%rip), %rax     # 0x37e98
movq %rax, 0x8(%rdi)
leaq 0x10(%rdi), %rbx
leaq 0x20(%rdi), %r13
movq %r13, 0x10(%rdi)
movq $0x0, 0x18(%rdi)
movb $0x0, 0x20(%rdi)
leaq 0xf3cf(%rip), %rcx      # 0x2b621
movq %rbx, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %r8d, %r8d
callq 0x8390
xorl %edi, %edi
callq 0x8220
leaq 0x8(%rsp), %rdi
movq %rax, (%rdi)
callq 0x81a0
movq %rax, %rdi
callq 0x80f0
movq %rax, %r15
movq 0x18(%r14), %r12
movq %rax, %rdi
callq 0x8100
movq %rbx, %rdi
xorl %esi, %esi
movq %r12, %rdx
movq %r15, %rcx
movq %rax, %r8
callq 0x8390
movq 0x10(%r14), %r15
leaq 0xec38(%rip), %rsi      # 0x2aee2
movq %r15, %rdi
callq 0x8060
movq 0x18(%r14), %rcx
cmpq %rax, %rcx
jb 0x1c2d2
movq %rax, 0x18(%r14)
movb $0x0, (%r15,%rax)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0xec23(%rip), %rdi      # 0x2aefc
leaq 0xec08(%rip), %rsi      # 0x2aee8
movq %rax, %rdx
xorl %eax, %eax
callq 0x8360
jmp 0x1c2ec
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r13, %rdi
je 0x1c303
movq (%r13), %rsi
incq %rsi
callq 0x8260
movq %r14, %rdi
callq 0x8420
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1ea3c
leal 0x1(%rax), %ecx
movl %ecx, 0x2d0(%rdi)
shlq $0x5, %rax
addq %rax, %rdi
addq $0x50, %rdi
jmp 0x8150
pushq %rax
leaq 0xc9e4(%rip), %rdi      # 0x2b428
callq 0x8380
movl $0x1, %edi
callq 0x82e0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsi), %rdx
leaq 0xc9a6(%rip), %rsi      # 0x2b419
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xfbb9
leaq 0xc337(%rip), %rsi      # 0x2adbe
movq %r15, %rdi
callq 0x8460
leaq 0x10(%rbx), %r15
movq %r15, (%rbx)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x1eab1
movq %rdx, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x1eab8
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rbx)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
leaq 0x18(%rsp), %r12
movq -0x10(%r12), %rdi
cmpq %r12, %rdi
je 0x1eaeb
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x8260
cmpl $0x0, 0x2d0(%r14)
jle 0x1eb1e
leaq 0x58(%r14), %r13
xorl %ebp, %ebp
movq -0x8(%r13), %rsi
movq (%r13), %rdx
movq %rbx, %rdi
callq 0x80b0
incq %rbp
movslq 0x2d0(%r14), %rax
addq $0x20, %r13
cmpq %rax, %rbp
jl 0x1eafb
addq $0x30, %r14
leaq 0xc248(%rip), %rsi      # 0x2ad71
leaq 0x8(%rsp), %rdi
movq %r14, %rdx
callq 0xfbb9
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x80b0
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x1eb5f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x8260
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x1ebaa
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x8260
jmp 0x1ebaa
jmp 0x1eba7
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1ebbd
movq 0x18(%rsp), %rsi
jmp 0x1ebb5
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x1ebbd
movq (%r15), %rsi
incq %rsi
callq 0x8260
movq %r14, %rdi
callq 0x8420
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
leaq 0x10(%rdi), %rax
movq %rax, (%rsp)
movq %rax, (%rdi)
movq 0x10(%rsi), %rsi
movq 0x18(%r14), %rdx
addq %rsi, %rdx
callq 0xabf6
leaq 0xa63d(%rip), %rsi      # 0x2a11f
movq %rbx, %rdi
callq 0x8460
cmpl $0x0, 0x2d0(%r14)
jle 0x1fb68
leaq 0x18(%rsp), %rbp
leaq 0x58(%r14), %r13
xorl %r12d, %r12d
leaq 0x8(%rsp), %r15
movq %rbp, 0x8(%rsp)
movq -0x8(%r13), %rsi
movq (%r13), %rdx
addq %rsi, %rdx
movq %r15, %rdi
callq 0xabf6
movq %r15, %rdi
leaq 0xa5f8(%rip), %rsi      # 0x2a11f
callq 0x8460
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x80b0
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x1fb55
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x8260
incq %r12
movslq 0x2d0(%r14), %rax
addq $0x20, %r13
cmpq %rax, %r12
jl 0x1fb05
movq 0x30(%r14), %rsi
movq 0x38(%r14), %rdx
movq %rbx, %rdi
callq 0x80b0
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1fb8e
jmp 0x1fb8e
movq %rax, %r14
jmp 0x1fbaf
jmp 0x1fb95
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x1fbaf
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x8260
movq (%rbx), %rdi
cmpq (%rsp), %rdi
je 0x1fbc7
movq (%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x8260
movq %r14, %rdi
callq 0x8420
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x40, %rsp
movq %rsi, %r14
leaq 0x1744e(%rip), %rsi     # 0x37b48
leaq 0x1741f(%rip), %rdx     # 0x37b20
xorl %ecx, %ecx
callq 0x82a0
movq %rax, %r15
movq %rax, %rdi
callq 0xfd20
movl %eax, %ebp
movl $0x58, %edi
callq 0x8250
movq %rax, %rbx
cmpl $0x1, %ebp
jg 0x20772
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0xafa8(%rip), %rsi      # 0x2b6e0
leaq 0xafa6(%rip), %rdx      # 0x2b6e5
leaq 0x20(%rsp), %rdi
callq 0xfc42
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
movl $0xa, %edx
callq 0x20250
movq (%r14), %rax
xorl %ebp, %ebp
movq %r14, %rdi
movq %rbx, %rsi
callq *(%rax)
movq 0x20(%rsp), %rdi
jmp 0x207b6
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0xaf5d(%rip), %rsi      # 0x2b6e0
leaq 0xaf5b(%rip), %rdx      # 0x2b6e5
movq %rsp, %rdi
callq 0xfc42
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
movl $0xa, %edx
callq 0x20250
movq (%r14), %rax
xorl %ebp, %ebp
movq %r14, %rdi
movq %rbx, %rsi
callq *(%rax)
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x207c7
movq (%r12), %rsi
incq %rsi
callq 0x8260
movq %r15, %rdi
callq 0x1091e
leaq 0x174f2(%rip), %rsi     # 0x37cc8
leaq 0x194eb(%rip), %rdx     # 0x39cc8
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x82a0
movq %rax, %rdi
movq %r14, %rsi
callq 0x20850
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x20801
movq %rax, %r14
movb $0x1, %bpl
jmp 0x20836
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x20836
movq 0x10(%rsp), %rsi
jmp 0x2082e
movq %rax, %r14
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x20836
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x8260
testb %bpl, %bpl
je 0x20848
movl $0x58, %esi
movq %rbx, %rdi
callq 0x8260
movq %r14, %rdi
callq 0x8420
// File: /workspace/github_cpp_makefile_star2_O1/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 0xb8f8
movl %eax, %ebp
movq %r14, %rdi
callq 0xb8fc
testb %bpl, %bpl
je 0x20dd4
testq %rax, %rax
je 0x20df6
leaq 0x16ffa(%rip), %rsi     # 0x37db8
leaq 0x18ed3(%rip), %rdx     # 0x39c98
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x82a0
movq %rax, %rdi
jmp 0x20df8
testq %rax, %rax
je 0x20e35
leaq 0x16fd8(%rip), %rsi     # 0x37db8
leaq 0x18eb1(%rip), %rdx     # 0x39c98
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x82a0
movq %rax, %rdi
jmp 0x20e37
xorl %edi, %edi
movq %rbx, %rsi
callq 0x222dc
movq %r14, %rdi
callq 0xb902
leaq 0x16eb9(%rip), %rsi     # 0x37cc8
leaq 0x18eb2(%rip), %rdx     # 0x39cc8
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x82a0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x20850
movq %r14, %rdi
callq 0xb908
jmp 0x20e47
xorl %edi, %edi
movq %rbx, %rsi
callq 0x222dc
movq %r14, %rdi
callq 0xb902
leaq 0x16e7a(%rip), %rsi     # 0x37cc8
leaq 0x18e73(%rip), %rdx     # 0x39cc8
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x82a0
movq %rax, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x20850
// File: /workspace/github_cpp_makefile_star2_O1/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 0xa8c2
testb %al, %al
je 0x20eab
movq %r14, %rdi
callq 0xabf0
testq %rax, %rax
je 0x20eb3
leaq 0x16f23(%rip), %rsi     # 0x37db8
leaq 0x16d9c(%rip), %rdx     # 0x37c38
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x82a0
movq %rax, %rdi
jmp 0x20eb5
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %edi, %edi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x222dc
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1b86a
cmpl $0x3, %eax
je 0x20f57
movl %eax, %ebp
cmpl $0x2, %eax
je 0x20f40
cmpl $0x1, %ebp
jne 0x20f6e
movl $0x10, %edi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x1d87c
jmp 0x20f85
movl $0x10, %edi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x1dae4
jmp 0x20f85
movl $0x10, %edi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x1d5e4
jmp 0x20f85
movl $0x18, %edi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
movl %ebp, %esi
callq 0x1cd44
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
movl $0x18, %esi
jmp 0x20fb1
jmp 0x20fa9
jmp 0x20fa9
movq %rax, %rbx
movl $0x10, %esi
movq %r14, %rdi
callq 0x8260
movq %rbx, %rdi
callq 0x8420
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1b86a
cmpl $0x3, %eax
je 0x2100d
movl %eax, %ebp
cmpl $0x2, %eax
je 0x20ff6
cmpl $0x1, %ebp
jne 0x21024
movl $0x10, %edi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x1edec
jmp 0x2103b
movl $0x10, %edi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x1ddb4
jmp 0x2103b
movl $0x10, %edi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x1cce4
jmp 0x2103b
movl $0x18, %edi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
movl %ebp, %esi
callq 0x1de7c
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
movl $0x18, %esi
jmp 0x21067
jmp 0x2105f
jmp 0x2105f
movq %rax, %rbx
movl $0x10, %esi
movq %r14, %rdi
callq 0x8260
movq %rbx, %rdi
callq 0x8420
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1b86a
cmpl $0x3, %eax
je 0x210c3
movl %eax, %ebp
cmpl $0x2, %eax
je 0x210ac
cmpl $0x1, %ebp
jne 0x210da
movl $0x10, %edi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x1cebc
jmp 0x210f1
movl $0x10, %edi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x1ebd8
jmp 0x210f1
movl $0x10, %edi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x1d580
jmp 0x210f1
movl $0x18, %edi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
movl %ebp, %esi
callq 0x1d408
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
movl $0x18, %esi
jmp 0x2111d
jmp 0x21115
jmp 0x21115
movq %rax, %rbx
movl $0x10, %esi
movq %r14, %rdi
callq 0x8260
movq %rbx, %rdi
callq 0x8420
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1b86a
cmpl $0x3, %eax
je 0x21179
movl %eax, %ebp
cmpl $0x2, %eax
je 0x21162
cmpl $0x1, %ebp
jne 0x21190
movl $0x10, %edi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x1ed8c
jmp 0x211a7
movl $0x10, %edi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x1ca98
jmp 0x211a7
movl $0x10, %edi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x1e2e8
jmp 0x211a7
movl $0x18, %edi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
movl %ebp, %esi
callq 0x1e170
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
movl $0x18, %esi
jmp 0x211d3
jmp 0x211cb
jmp 0x211cb
movq %rax, %rbx
movl $0x10, %esi
movq %r14, %rdi
callq 0x8260
movq %rbx, %rdi
callq 0x8420
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2126a
leaq 0xa4f1(%rip), %rcx      # 0x2b6f0
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movl $0x10, %edi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x1de14
jmp 0x212d0
movl $0x10, %edi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x1f080
jmp 0x212d0
movl $0x10, %edi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x1ed28
jmp 0x212d0
movl $0x10, %edi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x1d348
jmp 0x212d0
movsbl %r15b, %eax
cmpl %r15d, %eax
jne 0x212e7
movl $0x18, %edi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
movl %r15d, %esi
callq 0x1db48
jmp 0x212d0
movl $0x10, %edi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x1e0b0
jmp 0x212d0
movl $0x10, %edi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x1e04c
jmp 0x212d0
movl $0x10, %edi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x1da28
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 0x2130a
movl $0x18, %edi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
movl %r15d, %esi
callq 0x1f0e4
jmp 0x212d0
movl $0x38, %edi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
movl %r15d, %esi
callq 0x1e348
jmp 0x212d0
movq %rax, %rbx
movl $0x38, %esi
jmp 0x2134e
jmp 0x21330
movq %rax, %rbx
movl $0x18, %esi
jmp 0x2134e
jmp 0x21346
jmp 0x21346
jmp 0x21346
jmp 0x21346
jmp 0x21346
jmp 0x21346
movq %rax, %rbx
movl $0x10, %esi
movq %r14, %rdi
callq 0x8260
movq %rbx, %rdi
callq 0x8420
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x179b0
leaq 0xa387(%rip), %rsi      # 0x2b70c
movq %r15, %rdi
callq 0x80a0
movl %eax, %ebp
movq (%r15), %rdi
leaq 0x10(%rsp), %r12
cmpq %r12, %rdi
je 0x213a9
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x8260
testl %ebp, %ebp
je 0x213fc
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x179b0
leaq 0xa34c(%rip), %rsi      # 0x2b70e
movq %r15, %rdi
callq 0x80a0
movl %eax, %ebp
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x213e1
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x8260
testl %ebp, %ebp
jne 0x2142d
movl $0x10, %edi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x1d734
jmp 0x21411
movl $0x10, %edi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x1d3ac
addq $0x8, %r14
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *(%rax)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x18bbc(%rip), %rdi     # 0x39ff0
leaq 0xa2d5(%rip), %rsi      # 0x2b710
callq 0x8240
movq %rax, %rdi
callq 0x8120
movl $0x1, %edi
callq 0x82e0
jmp 0x21454
movq %rax, %rbx
movl $0x10, %esi
movq %r14, %rdi
callq 0x8260
movq %rbx, %rdi
callq 0x8420
// File: /workspace/github_cpp_makefile_star2_O1/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 %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x179b0
leaq 0xa29e(%rip), %rsi      # 0x2b731
movq %r15, %rdi
callq 0x80a0
movl %eax, %ebp
movq (%r15), %rdi
leaq 0x10(%rsp), %r12
cmpq %r12, %rdi
je 0x214b7
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x8260
testl %ebp, %ebp
je 0x21518
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x179b0
leaq 0x9241(%rip), %rsi      # 0x2a711
movq %r15, %rdi
callq 0x80a0
movl %eax, %ebp
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x214ef
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x8260
testl %ebp, %ebp
jne 0x21549
movl $0x10, %edi
callq 0x8250
leaq 0x8(%rax), %r14
leaq 0x186f0(%rip), %rcx     # 0x39bf8
movq %rcx, (%rax)
leaq 0x186fe(%rip), %rcx     # 0x39c10
movq %rcx, 0x8(%rax)
jmp 0x21531
movl $0x10, %edi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x1e114
addq $0x8, %r14
movq (%rbx), %rax
movq %rbx, %rdi
movq %r14, %rsi
callq *(%rax)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq 0x18aa0(%rip), %rdi     # 0x39ff0
leaq 0xa1dc(%rip), %rsi      # 0x2b733
callq 0x8240
movq %rax, %rdi
callq 0x8120
movl $0x1, %edi
callq 0x82e0
movq %rax, %rbx
movl $0x10, %esi
movq %r14, %rdi
callq 0x8260
movq %rbx, %rdi
callq 0x8420
// File: /workspace/github_cpp_makefile_star2_O1/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 %r13
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movq %rdi, %rbx
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x16f71(%rip), %r14     # 0x3a4f0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %rdi
callq 0xabf6
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x16f8c(%rip), %rax     # 0x3a530
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0xabf6
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
movq %rbx, %rdx
callq 0x23c3e
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x235dc
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x8260
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x235f3
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x8260
movl $0x10, %edi
callq 0x8250
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
leaq 0x8(%rax), %rsi
leaq 0x148f2(%rip), %r12     # 0x37f00
leaq 0x10(%r12), %r13
movq %r13, (%rax)
addq $0x28, %r12
movq %r12, 0x8(%rax)
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
leaq 0x90(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x80(%rsp), %r14
movq %r14, %rdi
callq 0xabf6
movq %r14, %rdi
movq %rbx, %rsi
callq 0x23e18
movq 0x80(%rsp), %rdi
cmpq %r15, %rdi
je 0x23674
movq 0x90(%rsp), %rsi
incq %rsi
callq 0x8260
leaq 0x70(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x16e8c(%rip), %rax     # 0x3a510
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq 0x60(%rsp), %r14
movq %r14, %rdi
callq 0xabf6
movq %r14, %rdi
movq %rbx, %rsi
callq 0x23ed0
movq 0x60(%rsp), %rdi
cmpq %r15, %rdi
je 0x236bd
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x8260
leaq 0x50(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x17023(%rip), %rax     # 0x3a6f0
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq 0x40(%rsp), %r14
movq %r14, %rdi
callq 0xabf6
movq %r14, %rdi
movq %rbx, %rsi
callq 0x23fde
movq 0x40(%rsp), %rdi
cmpq %r15, %rdi
je 0x23706
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x8260
movl $0x10, %edi
callq 0x8250
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
leaq 0x8(%rax), %rsi
movq %r13, (%rax)
movq %r12, 0x8(%rax)
movq (%rbx), %rax
movq %rbx, %rdi
callq *(%rax)
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x40(%rsp), %rdi
jmp 0x2377e
movq %rax, %rbx
movq 0x60(%rsp), %rdi
jmp 0x2377e
movq %rax, %rbx
movq 0x80(%rsp), %rdi
jmp 0x2377e
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x23779
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x8260
jmp 0x23779
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x2378e
movq (%r15), %rsi
incq %rsi
callq 0x8260
movq %rbx, %rdi
callq 0x8420
// File: /workspace/github_cpp_makefile_star2_O1/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, %ebp
movq %rdi, %r14
movq %rdx, %rdi
callq 0x24096
testl %ebp, %ebp
jle 0x23be7
movl %ebp, %r12d
xorl %r13d, %r13d
movq (%r14,%r13,8), %rdi
movq %rbx, %rsi
callq 0x206e4
movl $0x10, %edi
callq 0x8250
movq %rax, %r15
movq %rax, %rdi
callq 0x1dd54
addq $0x8, %r15
movq (%rbx), %rax
movq %rbx, %rdi
movq %r15, %rsi
callq *(%rax)
incq %r13
cmpq %r13, %r12
jne 0x23baf
movl $0x30, %edi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x20174
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
movl $0x30, %esi
movq %r14, %rdi
jmp 0x23c30
movq %rax, %rbx
movl $0x10, %esi
movq %r15, %rdi
callq 0x8260
movq %rbx, %rdi
callq 0x8420
nop
// File: /workspace/github_cpp_makefile_star2_O1/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, %r14
movq %rsi, %r15
movq %rdi, %r12
movl $0x10, %edi
callq 0x8250
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
leaq 0x8(%rax), %rsi
leaq 0x14430(%rip), %r13     # 0x380a0
leaq 0x10(%r13), %rcx
movq %rcx, (%rsp)
movq %rcx, (%rax)
addq $0x28, %r13
movq %r13, 0x8(%rax)
movq (%r14), %rax
movq %r14, %rdi
callq *(%rax)
movl $0x30, %edi
callq 0x8250
movq %rax, %rbx
leaq 0x38(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0xabf6
movb $0x1, %r12b
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x1c568
movq %rbx, %rsi
addq $0x8, %rsi
movq (%r14), %rax
xorl %r12d, %r12d
movq %r14, %rdi
callq *(%rax)
movq 0x28(%rsp), %rdi
cmpq %rbp, %rdi
je 0x23cf0
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x8260
movl $0x30, %edi
callq 0x8250
movq %rax, %rbx
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0xabf6
movb $0x1, %r15b
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x1c378
movq %rbx, %rsi
addq $0x8, %rsi
movq (%r14), %rax
xorl %r15d, %r15d
movq %r14, %rdi
callq *(%rax)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x23d54
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x8260
movl $0x30, %edi
callq 0x8250
movq %rax, %rbx
movq %rax, %rdi
callq 0x1c20e
addq $0x8, %rbx
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *(%rax)
movl $0x10, %edi
callq 0x8250
xorps %xmm0, %xmm0
movaps %xmm0, (%rax)
leaq 0x8(%rax), %rsi
movq (%rsp), %rcx
movq %rcx, (%rax)
movq %r13, 0x8(%rax)
movq (%r14), %rax
movq %r14, %rdi
callq *(%rax)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x23e03
movq %rax, %r14
movb $0x1, %r15b
jmp 0x23ddd
movq %rax, %r14
movb $0x1, %r12b
jmp 0x23dfe
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x23ddd
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x8260
testb %r15b, %r15b
jne 0x23e03
jmp 0x23e10
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %rbp, %rdi
je 0x23dfe
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x8260
testb %r12b, %r12b
je 0x23e10
movl $0x30, %esi
movq %rbx, %rdi
callq 0x8260
movq %r14, %rdi
callq 0x8420
// File: /workspace/github_cpp_makefile_star2_O1/martinda3[P]Compiler/src/JVM/JVMgenerateProgram.cpp
// Function: toyc::JVMgenerateProgram::gen_main_header(toyc::JVMtargetCode*)
void JVMgenerateProgram::gen_main_header(JVMtargetCode* tc) {
    method *m = new method("main", "V");
    m->addArg("[Ljava/lang/String;");
    m->addAccessSpec("public");
    m->addAccessSpec("static");
    tc->add(m);
  }

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %r14
movl $0x580, %edi            # imm = 0x580
callq 0x8250
movq %rax, %rbx
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x7714(%rip), %rsi      # 0x2b7d8
leaq 0x7711(%rip), %rdx      # 0x2b7dc
leaq 0x28(%rsp), %rdi
callq 0xfc42
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x7832(%rip), %rsi      # 0x2b918
leaq 0x782c(%rip), %rdx      # 0x2b919
leaq 0x8(%rsp), %rdi
callq 0xfc42
leaq 0x28(%rsp), %rsi
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x1f540
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x24120
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x8260
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x24137
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x8260
leaq 0x98(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x7692(%rip), %rsi      # 0x2b7dd
leaq 0x769e(%rip), %rdx      # 0x2b7f0
leaq 0x88(%rsp), %r15
movq %r15, %rdi
callq 0xfc42
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1f744
movq 0x88(%rsp), %rdi
cmpq %r12, %rdi
je 0x2418a
movq 0x98(%rsp), %rsi
incq %rsi
callq 0x8260
leaq 0x78(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x7636(%rip), %rsi      # 0x2b7d1
leaq 0x7635(%rip), %rdx      # 0x2b7d7
leaq 0x68(%rsp), %r15
movq %r15, %rdi
callq 0xfc42
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1f724
movq 0x68(%rsp), %rdi
cmpq %r12, %rdi
je 0x241d1
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x8260
leaq 0x58(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x760f(%rip), %rsi      # 0x2b7f1
leaq 0x760e(%rip), %rdx      # 0x2b7f7
leaq 0x48(%rsp), %r15
movq %r15, %rdi
callq 0xfc42
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1f724
movq 0x48(%rsp), %rdi
cmpq %r12, %rdi
je 0x24218
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x8260
movq (%r14), %rax
movq %r14, %rdi
movq %rbx, %rsi
callq *(%rax)
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq 0x48(%rsp), %rdi
cmpq %r12, %rdi
je 0x242c3
movq 0x58(%rsp), %rsi
jmp 0x24276
movq %rax, %r14
movq 0x68(%rsp), %rdi
cmpq %r12, %rdi
je 0x242c3
movq 0x78(%rsp), %rsi
jmp 0x24276
movq %rax, %r14
movq 0x88(%rsp), %rdi
cmpq %r12, %rdi
je 0x242c3
movq 0x98(%rsp), %rsi
incq %rsi
jmp 0x242be
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x2429a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x8260
jmp 0x2429a
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x242b6
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x8260
jmp 0x242b6
movq %rax, %r14
movl $0x580, %esi            # imm = 0x580
movq %rbx, %rdi
callq 0x8260
movq %r14, %rdi
callq 0x8420