LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/martinda3[P]Compiler/src/TCparser.cpp
// Function: toyc::TCparser::ReturnStatement()
ASstatement* TCparser::ReturnStatement() // WIP
	{
		// RETURN [ Expression ] SEMICOLON
		enteringDEBUG("Return Statement");
		ASexpression* operand = NULL;
		accept(RETURN);
		try
		{
			operand = Expression();
			accept(SEMICOLON);
			exitingDEBUG("Return Statement");
			return new ASreturnState(operand);
		}
		catch (int t)
		{
			accept(SEMICOLON);
			exitingDEBUG("Return Statement");
			return new ASreturnState();
		}
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
leaq 0x58(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1c443(%rip), %rsi     # 0x2a2cf
leaq 0x1c44c(%rip), %rdx     # 0x2a2df
leaq 0x48(%rsp), %r14
movq %r14, %rdi
callq 0xfc2a
movq %r14, %rdi
callq 0xbaaa
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0xdebf
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x8260
movq %rbx, %rdi
movl $0xa, %esi
callq 0xc54c
movq %rbx, %rdi
callq 0xd66a
movq %rax, %r14
movq %rbx, %rdi
movl $0x27, %esi
callq 0xc54c
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1c3db(%rip), %rsi     # 0x2a2cf
leaq 0x1c3e4(%rip), %rdx     # 0x2a2df
leaq 0x28(%rsp), %rdi
callq 0xfc2a
leaq 0x28(%rsp), %rdi
callq 0xbd0c
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0xdf26
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x8260
movl $0x40, %edi
callq 0x8250
movq %rax, %r15
movq %rax, %rdi
movq %r14, %rsi
callq 0xa80c
movq %r15, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rdx, %r12
movq %rax, %r14
movl $0x40, %esi
movq %r15, %rdi
jmp 0xdf75
movq %rdx, %r12
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0xdfa6
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x8260
jmp 0xdfa6
jmp 0xdfa0
movq %rax, %r14
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0xdf98
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x8260
movq %r14, %rdi
callq 0x8420
movq %rdx, %r12
movq %rax, %r14
cmpl $0x1, %r12d
jne 0xdf98
movq %r14, %rdi
callq 0x80e0
movq %rbx, %rdi
movl $0x27, %esi
callq 0xc54c
leaq 0x18(%rsp), %rbx
movq %rbx, -0x10(%rbx)
leaq 0x1c2fe(%rip), %rsi     # 0x2a2cf
leaq 0x1c307(%rip), %rdx     # 0x2a2df
leaq 0x8(%rsp), %rdi
callq 0xfc2a
leaq 0x8(%rsp), %rdi
callq 0xbd0c
movq 0x8(%rsp), %rdi
cmpq %rbx, %rdi
je 0xe003
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x8260
movl $0x40, %edi
callq 0x8250
movq %rax, %r15
movq %rax, %rdi
callq 0xa874
callq 0x83d0
jmp 0xdf3e
movq %rax, %r14
movl $0x40, %esi
movq %r15, %rdi
jmp 0xe044
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %rbx, %rdi
je 0xe050
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x8260
jmp 0xe050
jmp 0xe04d
movq %rax, %r14
callq 0x83d0
jmp 0xdf98
// File: /workspace/github_cpp_makefile_star2_O3/martinda3[P]Compiler/src/TCparser.cpp
// Function: toyc::TCparser::WhileStatement()
ASstatement* TCparser::WhileStatement() // Testing
	{
		// WHILE LPAREN Expression RPAREN Statement
		enteringDEBUG("While Statement");
		ASexpression* operand = NULL;
		ASstatement* operand2 = NULL;
		accept(WHILE);
		accept(LPAREN);
		operand = Expression();
		accept(RPAREN);
		operand2 = Statement();
		exitingDEBUG("While Statement");
		return new ASwhileState(operand, operand2);
	}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1c268(%rip), %rsi     # 0x2a2e0
leaq 0x1c270(%rip), %rdx     # 0x2a2ef
leaq 0x28(%rsp), %rbx
movq %rbx, %rdi
callq 0xfc2a
movq %rbx, %rdi
callq 0xbaaa
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0xe0ab
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x8260
movq %r14, %rdi
movl $0x8, %esi
callq 0xc54c
movq %r14, %rdi
movl $0x1e, %esi
callq 0xc54c
movq %r14, %rdi
callq 0xd66a
movq %rax, %rbx
movq %r14, %rdi
movl $0x1f, %esi
callq 0xc54c
movq %r14, %rdi
callq 0xd92e
movq %rax, %r14
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x1c1e7(%rip), %rsi     # 0x2a2e0
leaq 0x1c1ef(%rip), %rdx     # 0x2a2ef
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xfc2a
movq %r15, %rdi
callq 0xbd0c
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xe12c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x8260
movl $0x20, %edi
callq 0x8250
movq %rax, %r15
movq %rax, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x19824
movq %r15, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x20, %esi
movq %r15, %rdi
jmp 0xe18c
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xe191
movq 0x18(%rsp), %rsi
jmp 0xe189
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0xe191
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x8260
movq %rbx, %rdi
callq 0x8420
nop
// File: /workspace/github_cpp_makefile_star2_O3/martinda3[P]Compiler/src/TCparser.cpp
// Function: toyc::TCparser::WriteStatement()
ASstatement* TCparser::WriteStatement() // WIP
	{
		// WriteStatement -> WRITE LPAREN ActualParameters RPAREN SEMICOLON
		enteringDEBUG("Write Statement");
		ASexpression* operand = NULL;
		ASexpression* operand2[MAX_STATEMENTS];
		accept(WRITE);
        enter_special_id(symTable,WRITE);
		accept(LPAREN);
		operand = ActualParameters();
		operand2[0] = operand;
		accept(RPAREN);
		exitingDEBUG("Write Statement");
		accept(SEMICOLON);
		return new ASwriteState(operand2, 1);
	}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xfe0, %rsp            # imm = 0xFE0
movq %rdi, %rbx
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1bcd2(%rip), %rsi     # 0x2a353
leaq 0x1bcda(%rip), %rdx     # 0x2a362
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0xfc2a
movq %r14, %rdi
callq 0xbaaa
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0xe6b4
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x8260
movq %rbx, %rdi
movl $0xc, %esi
callq 0xc54c
leaq 0x2bea8(%rip), %rax     # 0x3a570
movq (%rax), %rdi
movl $0xc, %esi
callq 0xe8c9
movq %rbx, %rdi
movl $0x1e, %esi
callq 0xc54c
movq %rbx, %rdi
callq 0xe9b6
movq %rax, 0x40(%rsp)
movq %rbx, %rdi
movl $0x1f, %esi
callq 0xc54c
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x1bc47(%rip), %rsi     # 0x2a353
leaq 0x1bc4f(%rip), %rdx     # 0x2a362
movq %rsp, %rdi
callq 0xfc2a
movq %rsp, %rdi
callq 0xbd0c
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0xe739
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x8260
movq %rbx, %rdi
movl $0x27, %esi
callq 0xc54c
movl $0xfb8, %edi            # imm = 0xFB8
callq 0x8250
movq %rax, %r14
leaq 0x40(%rsp), %rsi
movq %rax, %rdi
movl $0x1, %edx
callq 0x1a69c
movq %r14, %rax
addq $0xfe0, %rsp            # imm = 0xFE0
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0xfb8, %esi            # imm = 0xFB8
movq %r14, %rdi
jmp 0xe7af
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0xe7b4
movq 0x10(%rsp), %rsi
jmp 0xe7ac
movq %rax, %rbx
jmp 0xe7b4
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0xe7b4
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x8260
movq %rbx, %rdi
callq 0x8420
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1bb8b(%rip), %rsi     # 0x2a363
leaq 0x1bb95(%rip), %rdx     # 0x2a374
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0xfc2a
movq %r14, %rdi
callq 0xbaaa
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0xe80b
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x8260
movq %rbx, %rdi
movl $0xf, %esi
callq 0xc54c
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1bb3b(%rip), %rsi     # 0x2a363
leaq 0x1bb45(%rip), %rdx     # 0x2a374
movq %rsp, %r14
movq %r14, %rdi
callq 0xfc2a
movq %r14, %rdi
callq 0xbd0c
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xe858
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x8260
movq %rbx, %rdi
movl $0x27, %esi
callq 0xc54c
movl $0x10, %edi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x1bc80
movq %r14, %rax
addq $0x40, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movl $0x10, %esi
movq %r14, %rdi
jmp 0xe8bc
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xe8c1
movq 0x10(%rsp), %rsi
jmp 0xe8b9
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0xe8c1
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x8260
movq %rbx, %rdi
callq 0x8420
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1bd54
movq %rbx, %rdi
movl $0x2, %esi
callq 0x1be6a
xorl %eax, %eax
cmpl $0x7, %ebp
sete %al
leaq 0x1bb9c(%rip), %rcx     # 0x2a4a7
leaq 0x1bb9f(%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 0xfc2a
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1be60
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0xe957
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x8260
leaq 0x2b906(%rip), %rax     # 0x3a264
movl (%rax), %esi
movq %rbx, %rdi
callq 0x1bec0
movq %rbx, %rdi
callq 0x1bec4
movq %r14, %rdi
movq %rbx, %rsi
callq 0x28e2c
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0xe9ae
movq 0x10(%rsp), %rsi
incq %rsi
jmp 0xe9a9
movq %rax, %r14
movl $0x48, %esi
movq %rbx, %rdi
callq 0x8260
movq %r14, %rdi
callq 0x8420
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1a9f5(%rip), %rsi     # 0x2a46a
leaq 0x1a9fb(%rip), %rdx     # 0x2a477
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0xfc2a
movq %r14, %rdi
callq 0xbaaa
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0xfaa8
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x8260
movq %rbx, %rdi
movl $0x1e, %esi
callq 0xc54c
movq %rbx, %rdi
callq 0xe9b6
movq %rax, %r14
movq %rbx, %rdi
movl $0x1f, %esi
callq 0xc54c
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x1a98c(%rip), %rsi     # 0x2a46a
leaq 0x1a992(%rip), %rdx     # 0x2a477
leaq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0xfc2a
movq %rbx, %rdi
callq 0xbd0c
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0xfb11
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 0xfb99
movq 0x18(%rsp), %rsi
jmp 0xfb91
movq %rax, %r15
cmpl $0x1, %edx
jne 0xfb99
movq %r15, %rdi
callq 0x80e0
movl $0x10, %edi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x1c478
callq 0x83d0
jmp 0xfac0
movq %rax, %r15
movl $0x10, %esi
movq %r14, %rdi
callq 0x8260
jmp 0xfb78
movq %rax, %r15
callq 0x83d0
jmp 0xfb99
movq %rax, %r15
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0xfb99
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x8260
movq %r15, %rdi
callq 0x8420
// File: /workspace/github_cpp_makefile_star2_O3/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 0x27eb9(%rip), %rax     # 0x37b80
movq %rax, (%rdi)
movq %rsi, 0x10(%rdi)
testl %ecx, %ecx
jle 0xfce7
movl %ecx, %eax
xorl %esi, %esi
movq (%rdx,%rsi,8), %r9
movq %r9, 0x18(%rdi,%rsi,8)
incq %rsi
cmpq %rsi, %rax
jne 0xfcd6
movl %ecx, 0xfb8(%rdi)
movq %r8, 0xfc0(%rdi)
xorl %esi, %esi
jmp 0x253f4
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x13e19(%rip), %rdx     # 0x2b621
movq %rdx, %rsi
callq 0xfc2a
testl %ebp, %ebp
jle 0x1782a
leaq 0x12904(%rip), %r14     # 0x2a11f
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8460
decl %ebp
jne 0x1781b
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 0x1784e
movq (%r15), %rsi
incq %rsi
callq 0x8260
movq %r14, %rdi
callq 0x8420
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1ae1c
leaq 0x1f173(%rip), %rax     # 0x37c38
movq %rax, (%r14)
testl %ebx, %ebx
jle 0x18ae1
movl %ebx, %eax
xorl %ecx, %ecx
movq (%r15,%rcx,8), %rdx
movq %rdx, 0x10(%r14,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x18ad0
movl %ebx, 0xfb0(%r14)
movq %r14, %rdi
movl $0x7, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x1ae2e
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1ae1c
leaq 0x1d613(%rip), %rax     # 0x37cc8
movq %rax, (%r14)
testl %ebx, %ebx
jle 0x1a6d1
movl %ebx, %eax
xorl %ecx, %ecx
movq (%r15,%rcx,8), %rdx
movq %rdx, 0x10(%r14,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x1a6c0
movl %ebx, 0xfb0(%r14)
movq %r14, %rdi
movl $0x8, %esi
popq %rbx
popq %r14
popq %r15
jmp 0x1ae2e
// File: /workspace/github_cpp_makefile_star2_O3/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 0x10100(%rip), %rdx     # 0x2abe3
leaq 0x10c41(%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 0x1ab1e
movq (%r15), %rsi
incq %rsi
callq 0x8260
movq %r14, %rdi
callq 0x8420
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1ce79(%rip), %rax     # 0x37d58
movq %rax, (%rdi)
testl %edx, %edx
jle 0x1aefb
movl %edx, %eax
xorl %ecx, %ecx
movq (%rsi,%rcx,8), %r8
movq %r8, 0x10(%rdi,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x1aeea
movl %edx, 0xfb0(%rdi)
movl $0x1, %esi
jmp 0x253f4
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1c478
leaq 0x1ca89(%rip), %rax     # 0x37d88
movq %rax, (%r14)
testl %ebx, %ebx
jle 0x1b31b
movl %ebx, %eax
xorl %ecx, %ecx
movq (%r12,%rcx,8), %rdx
movq %rdx, 0x10(%r14,%rcx,8)
incq %rcx
cmpq %rcx, %rax
jne 0x1b30a
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 0x1c48a
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1c5ec
leal 0x1(%rax), %ecx
movl %ecx, 0xfa8(%rdi)
movq %rsi, 0x8(%rdi,%rax,8)
retq
pushq %rax
movq 0x1d9fc(%rip), %rdi     # 0x39ff0
leaq 0xe898(%rip), %rsi      # 0x2ae93
callq 0x8240
movq %rax, %rdi
callq 0x8120
movl $0x1, %edi
callq 0x82e0
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1c6db
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 0x1c6d7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x8260
incl %ebp
jmp 0x1c661
leaq 0x28(%rsp), %rdi
callq 0x8310
movq 0x1d8dc(%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 0x1c72d
jmp 0x1c72d
movq %rax, %rbx
jmp 0x1c74c
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x1c74c
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_O3/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 0x1b74e(%rip), %rax     # 0x37ee8
movq %rax, (%rdi)
leaq 0x1b75c(%rip), %rax     # 0x37f00
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 0x1c812
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0x1c829
movq (%r12), %rsi
incq %rsi
callq 0x8260
movq %r14, %rdi
callq 0x8420
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1b69f(%rip), %rax     # 0x37ee8
movq %rax, (%rdi)
leaq 0x1b6ad(%rip), %rax     # 0x37f00
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 0xedab(%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 0xe614(%rip), %rsi      # 0x2aee2
movq %r15, %rdi
callq 0x8060
movq 0x18(%r14), %rcx
cmpq %rax, %rcx
jb 0x1c8f6
movq %rax, 0x18(%r14)
movb $0x0, (%r15,%rax)
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
leaq 0xe5ff(%rip), %rdi      # 0x2aefc
leaq 0xe5e4(%rip), %rsi      # 0x2aee8
movq %rax, %rdx
xorl %eax, %eax
callq 0x8360
jmp 0x1c910
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r13, %rdi
je 0x1c927
movq (%r13), %rsi
incq %rsi
callq 0x8260
movq %r14, %rdi
callq 0x8420
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1f05c
leal 0x1(%rax), %ecx
movl %ecx, 0x2d0(%rdi)
shlq $0x5, %rax
addq %rax, %rdi
addq $0x50, %rdi
jmp 0x8150
pushq %rax
leaq 0xc3c4(%rip), %rdi      # 0x2b428
callq 0x8380
movl $0x1, %edi
callq 0x82e0
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xc386(%rip), %rsi      # 0x2b419
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0xfba1
leaq 0xbd17(%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 0x1f0d1
movq %rdx, (%rbx)
movq (%rcx), %rdx
movq %rdx, 0x10(%rbx)
jmp 0x1f0d8
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 0x1f10b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x8260
cmpl $0x0, 0x2d0(%r14)
jle 0x1f13e
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 0x1f11b
addq $0x30, %r14
leaq 0xbc28(%rip), %rsi      # 0x2ad71
leaq 0x8(%rsp), %rdi
movq %r14, %rdx
callq 0xfba1
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
movq %rbx, %rdi
callq 0x80b0
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x1f17f
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 0x1f1ca
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x8260
jmp 0x1f1ca
jmp 0x1f1c7
movq %rax, %r14
leaq 0x18(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1f1dd
movq 0x18(%rsp), %rsi
jmp 0x1f1d5
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x1f1dd
movq (%r15), %rsi
incq %rsi
callq 0x8260
movq %r14, %rdi
callq 0x8420
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xabdc
leaq 0xa01d(%rip), %rsi      # 0x2a11f
movq %rbx, %rdi
callq 0x8460
cmpl $0x0, 0x2d0(%r14)
jle 0x20188
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 0xabdc
movq %r15, %rdi
leaq 0x9fd8(%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 0x20175
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x8260
incq %r12
movslq 0x2d0(%r14), %rax
addq $0x20, %r13
cmpq %rax, %r12
jl 0x20125
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 0x201ae
jmp 0x201ae
movq %rax, %r14
jmp 0x201cf
jmp 0x201b5
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x201cf
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x8260
movq (%rbx), %rdi
cmpq (%rsp), %rdi
je 0x201e7
movq (%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x8260
movq %r14, %rdi
callq 0x8420
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x16e9a(%rip), %rsi     # 0x37bb0
leaq 0x16e6b(%rip), %rdx     # 0x37b88
xorl %ecx, %ecx
callq 0x82a0
movq %rax, %r15
movq %rax, %rdi
callq 0xfd0c
movl %eax, %ebp
movl $0x58, %edi
callq 0x8250
movq %rax, %rbx
cmpl $0x1, %ebp
jg 0x20d8e
leaq 0x30(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0xa98c(%rip), %rsi      # 0x2b6e0
leaq 0xa98a(%rip), %rdx      # 0x2b6e5
leaq 0x20(%rsp), %rdi
callq 0xfc2a
movb $0x1, %bpl
leaq 0x20(%rsp), %rsi
movq %rbx, %rdi
movl $0xa, %edx
callq 0x20870
movq (%r14), %rax
xorl %ebp, %ebp
movq %r14, %rdi
movq %rbx, %rsi
callq *(%rax)
movq 0x20(%rsp), %rdi
jmp 0x20dd2
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0xa941(%rip), %rsi      # 0x2b6e0
leaq 0xa93f(%rip), %rdx      # 0x2b6e5
movq %rsp, %rdi
callq 0xfc2a
movb $0x1, %bpl
movq %rsp, %rsi
movq %rbx, %rdi
movl $0xa, %edx
callq 0x20870
movq (%r14), %rax
xorl %ebp, %ebp
movq %r14, %rdi
movq %rbx, %rsi
callq *(%rax)
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x20de3
movq (%r12), %rsi
incq %rsi
callq 0x8260
movq %r15, %rdi
callq 0x1090c
leaq 0x16f3e(%rip), %rsi     # 0x37d30
leaq 0x18ecf(%rip), %rdx     # 0x39cc8
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x82a0
movq %rax, %rdi
movq %r14, %rsi
callq 0x20e6a
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x20e1d
movq %rax, %r14
jmp 0x20e54
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x20e4f
movq 0x10(%rsp), %rsi
jmp 0x20e47
movq %rax, %r14
movq 0x20(%rsp), %rdi
cmpq %r12, %rdi
je 0x20e4f
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x8260
testb %bpl, %bpl
je 0x20e61
movl $0x58, %esi
movq %rbx, %rdi
callq 0x8260
movq %r14, %rdi
callq 0x8420
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0xb8de
movl %eax, %ebp
movq %r14, %rdi
callq 0xb8e2
testb %bpl, %bpl
je 0x213fa
testq %rax, %rax
je 0x2141c
leaq 0x16a3c(%rip), %rsi     # 0x37e20
leaq 0x188ad(%rip), %rdx     # 0x39c98
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x82a0
movq %rax, %rdi
jmp 0x2141e
testq %rax, %rax
je 0x2145b
leaq 0x16a1a(%rip), %rsi     # 0x37e20
leaq 0x1888b(%rip), %rdx     # 0x39c98
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x82a0
movq %rax, %rdi
jmp 0x2145d
xorl %edi, %edi
movq %rbx, %rsi
callq 0x228fc
movq %r14, %rdi
callq 0xb8e8
leaq 0x168fb(%rip), %rsi     # 0x37d30
leaq 0x1888c(%rip), %rdx     # 0x39cc8
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x82a0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x20e6a
movq %r14, %rdi
callq 0xb8ee
jmp 0x2146d
xorl %edi, %edi
movq %rbx, %rsi
callq 0x228fc
movq %r14, %rdi
callq 0xb8e8
leaq 0x168bc(%rip), %rsi     # 0x37d30
leaq 0x1884d(%rip), %rdx     # 0x39cc8
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x82a0
movq %rax, %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %rbp
jmp 0x20e6a
// File: /workspace/github_cpp_makefile_star2_O3/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 0xa8a2
testb %al, %al
je 0x214d1
movq %r14, %rdi
callq 0xabd6
testq %rax, %rax
je 0x214d9
leaq 0x16965(%rip), %rsi     # 0x37e20
leaq 0x167de(%rip), %rdx     # 0x37ca0
movq %rax, %rdi
xorl %ecx, %ecx
callq 0x82a0
movq %rax, %rdi
jmp 0x214db
addq $0x8, %rsp
popq %rbx
popq %r14
retq
xorl %edi, %edi
movq %rbx, %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x228fc
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1be8e
cmpl $0x3, %eax
je 0x2157b
movl %eax, %ebp
cmpl $0x2, %eax
je 0x21564
cmpl $0x1, %ebp
jne 0x21592
movl $0x10, %edi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x1de98
jmp 0x215a9
movl $0x10, %edi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x1e100
jmp 0x215a9
movl $0x10, %edi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x1dc00
jmp 0x215a9
movl $0x18, %edi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
movl %ebp, %esi
callq 0x1d360
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 0x215d5
jmp 0x215cd
jmp 0x215cd
movq %rax, %rbx
movl $0x10, %esi
movq %r14, %rdi
callq 0x8260
movq %rbx, %rdi
callq 0x8420
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1be8e
cmpl $0x3, %eax
je 0x21631
movl %eax, %ebp
cmpl $0x2, %eax
je 0x2161a
cmpl $0x1, %ebp
jne 0x21648
movl $0x10, %edi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x1f40c
jmp 0x2165f
movl $0x10, %edi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x1e3d0
jmp 0x2165f
movl $0x10, %edi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x1d300
jmp 0x2165f
movl $0x18, %edi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
movl %ebp, %esi
callq 0x1e498
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 0x2168b
jmp 0x21683
jmp 0x21683
movq %rax, %rbx
movl $0x10, %esi
movq %r14, %rdi
callq 0x8260
movq %rbx, %rdi
callq 0x8420
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1be8e
cmpl $0x3, %eax
je 0x216e7
movl %eax, %ebp
cmpl $0x2, %eax
je 0x216d0
cmpl $0x1, %ebp
jne 0x216fe
movl $0x10, %edi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x1d4d8
jmp 0x21715
movl $0x10, %edi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x1f1f8
jmp 0x21715
movl $0x10, %edi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x1db9c
jmp 0x21715
movl $0x18, %edi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
movl %ebp, %esi
callq 0x1da24
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 0x21741
jmp 0x21739
jmp 0x21739
movq %rax, %rbx
movl $0x10, %esi
movq %r14, %rdi
callq 0x8260
movq %rbx, %rdi
callq 0x8420
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x1be8e
cmpl $0x3, %eax
je 0x2179d
movl %eax, %ebp
cmpl $0x2, %eax
je 0x21786
cmpl $0x1, %ebp
jne 0x217b4
movl $0x10, %edi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x1f3ac
jmp 0x217cb
movl $0x10, %edi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x1d0b4
jmp 0x217cb
movl $0x10, %edi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x1e904
jmp 0x217cb
movl $0x18, %edi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
movl %ebp, %esi
callq 0x1e78c
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 0x217f7
jmp 0x217ef
jmp 0x217ef
movq %rax, %rbx
movl $0x10, %esi
movq %r14, %rdi
callq 0x8260
movq %rbx, %rdi
callq 0x8420
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2188e
leaq 0x9ecd(%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 0x1e430
jmp 0x218f4
movl $0x10, %edi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x1f6a0
jmp 0x218f4
movl $0x10, %edi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x1f348
jmp 0x218f4
movl $0x10, %edi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x1d964
jmp 0x218f4
movsbl %r15b, %eax
cmpl %r15d, %eax
jne 0x2190b
movl $0x18, %edi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
movl %r15d, %esi
callq 0x1e164
jmp 0x218f4
movl $0x10, %edi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x1e6cc
jmp 0x218f4
movl $0x10, %edi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x1e668
jmp 0x218f4
movl $0x10, %edi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x1e044
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 0x2192e
movl $0x18, %edi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
movl %r15d, %esi
callq 0x1f704
jmp 0x218f4
movl $0x38, %edi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
movl %r15d, %esi
callq 0x1e964
jmp 0x218f4
movq %rax, %rbx
movl $0x38, %esi
jmp 0x21972
jmp 0x21954
movq %rax, %rbx
movl $0x18, %esi
jmp 0x21972
jmp 0x2196a
jmp 0x2196a
jmp 0x2196a
jmp 0x2196a
jmp 0x2196a
jmp 0x2196a
movq %rax, %rbx
movl $0x10, %esi
movq %r14, %rdi
callq 0x8260
movq %rbx, %rdi
callq 0x8420
// File: /workspace/github_cpp_makefile_star2_O3/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 0x17fd0
leaq 0x9d63(%rip), %rsi      # 0x2b70c
movq %r15, %rdi
callq 0x80a0
movl %eax, %ebp
movq (%r15), %rdi
leaq 0x10(%rsp), %r12
cmpq %r12, %rdi
je 0x219cd
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x8260
testl %ebp, %ebp
je 0x21a20
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x17fd0
leaq 0x9d28(%rip), %rsi      # 0x2b70e
movq %r15, %rdi
callq 0x80a0
movl %eax, %ebp
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x21a05
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x8260
testl %ebp, %ebp
jne 0x21a51
movl $0x10, %edi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x1dd50
jmp 0x21a35
movl $0x10, %edi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x1d9c8
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 0x18598(%rip), %rdi     # 0x39ff0
leaq 0x9cb1(%rip), %rsi      # 0x2b710
callq 0x8240
movq %rax, %rdi
callq 0x8120
movl $0x1, %edi
callq 0x82e0
jmp 0x21a78
movq %rax, %rbx
movl $0x10, %esi
movq %r14, %rdi
callq 0x8260
movq %rbx, %rdi
callq 0x8420
// File: /workspace/github_cpp_makefile_star2_O3/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 0x17fd0
leaq 0x9c7a(%rip), %rsi      # 0x2b731
movq %r15, %rdi
callq 0x80a0
movl %eax, %ebp
movq (%r15), %rdi
leaq 0x10(%rsp), %r12
cmpq %r12, %rdi
je 0x21adb
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x8260
testl %ebp, %ebp
je 0x21b3c
movq %rsp, %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x17fd0
leaq 0x8c1d(%rip), %rsi      # 0x2a711
movq %r15, %rdi
callq 0x80a0
movl %eax, %ebp
movq (%r15), %rdi
cmpq %r12, %rdi
je 0x21b13
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x8260
testl %ebp, %ebp
jne 0x21b6d
movl $0x10, %edi
callq 0x8250
leaq 0x8(%rax), %r14
leaq 0x180cc(%rip), %rcx     # 0x39bf8
movq %rcx, (%rax)
leaq 0x180da(%rip), %rcx     # 0x39c10
movq %rcx, 0x8(%rax)
jmp 0x21b55
movl $0x10, %edi
callq 0x8250
movq %rax, %r14
movq %rax, %rdi
callq 0x1e730
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 0x1847c(%rip), %rdi     # 0x39ff0
leaq 0x9bb8(%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_O3/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 0x16919(%rip), %r14     # 0x3a4f0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %rdi
callq 0xabdc
leaq 0x10(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x16934(%rip), %rax     # 0x3a530
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
movq %rsp, %rdi
callq 0xabdc
leaq 0x20(%rsp), %rdi
movq %rsp, %rsi
movq %rbx, %rdx
callq 0x24278
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x23c34
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x8260
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x23c4b
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x8260
movl $0x10, %edi
callq 0x8250
leaq 0x8(%rax), %rsi
leaq 0x142f0(%rip), %r12     # 0x37f50
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 0xabdc
movq %r14, %rdi
movq %rbx, %rsi
callq 0x2443a
movq 0x80(%rsp), %rdi
cmpq %r15, %rdi
je 0x23cc6
movq 0x90(%rsp), %rsi
incq %rsi
callq 0x8260
leaq 0x70(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x1683a(%rip), %rax     # 0x3a510
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq 0x60(%rsp), %r14
movq %r14, %rdi
callq 0xabdc
movq %r14, %rdi
movq %rbx, %rsi
callq 0x244f0
movq 0x60(%rsp), %rdi
cmpq %r15, %rdi
je 0x23d0f
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x8260
leaq 0x50(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x169d1(%rip), %rax     # 0x3a6f0
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq 0x40(%rsp), %r14
movq %r14, %rdi
callq 0xabdc
movq %r14, %rdi
movq %rbx, %rsi
callq 0x245fe
movq 0x40(%rsp), %rdi
cmpq %r15, %rdi
je 0x23d58
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x8260
movl $0x10, %edi
callq 0x8250
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 0x23dca
movq %rax, %rbx
movq 0x60(%rsp), %rdi
jmp 0x23dca
movq %rax, %rbx
movq 0x80(%rsp), %rdi
jmp 0x23dca
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r12, %rdi
je 0x23dc5
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x8260
jmp 0x23dc5
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x23dda
movq (%r15), %rsi
incq %rsi
callq 0x8260
movq %rbx, %rdi
callq 0x8420