LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/AndrewAlbert[P]Compiler-Theory/SourceCode/parser.cpp
// Function: Parser::Parameter(scopeValue&)
bool Parser::Parameter(scopeValue &procEntry){
	scopeValue paramEntry;
	string id;
	//get parameter declaration
	if( VariableDeclaration(id, paramEntry) ){
		//determine parameter's input / output type
		if(CheckToken(T_IN)) paramEntry.paramType = TYPE_PARAM_IN;
		else if(CheckToken(T_OUT)) paramEntry.paramType = TYPE_PARAM_OUT;
		else if(CheckToken(T_INOUT)) paramEntry.paramType = TYPE_PARAM_INOUT;
		else ReportError("expected 'in', 'out', or 'inout' in parameter declaration");
		
		//add parameter to current scope after updating the parameter type
		Scopes->addSymbol(id, paramEntry, false);
		
		//add to current procedure declaration's parameter list
		procEntry.arguments.push_back(paramEntry);
		
		return true;
	}
	else return false;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
leaq 0xa0(%rsp), %rax
movups %xmm0, -0x28(%rax)
andq $0x0, -0x18(%rax)
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
xorl %ecx, %ecx
movb %cl, (%rax)
leaq 0x20(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb %cl, (%rax)
leaq 0x10(%rsp), %rsi
leaq 0x70(%rsp), %rdx
callq 0x5698
movl %eax, %ebp
testb %al, %al
je 0x6713
movq %r14, %rdi
movl $0x107, %esi            # imm = 0x107
callq 0x49b0
testb %al, %al
je 0x6643
movl $0x11f, 0xb0(%rsp) # imm = 0x11F
jmp 0x66ac
movq %r14, %rdi
movl $0x108, %esi            # imm = 0x108
callq 0x49b0
testb %al, %al
je 0x6661
movl $0x120, 0xb0(%rsp) # imm = 0x120
jmp 0x66ac
movq %r14, %rdi
movl $0x109, %esi            # imm = 0x109
callq 0x49b0
testb %al, %al
je 0x667f
movl $0x121, 0xb0(%rsp) # imm = 0x121
jmp 0x66ac
leaq 0xb41e(%rip), %rsi      # 0x11aa4
leaq 0x50(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x36b8
leaq 0x50(%rsp), %rsi
movq %r14, %rdi
callq 0x47e0
leaq 0x50(%rsp), %rdi
callq 0x20f0
movq 0x90(%r14), %r14
leaq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
callq 0x2270
leaq 0xb8(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0x97e6
leaq 0x30(%rsp), %rsi
leaq 0xb8(%rsp), %rdx
movq %r14, %rdi
xorl %ecx, %ecx
callq 0xb1c2
leaq 0xb8(%rsp), %rdi
callq 0x9836
leaq 0x30(%rsp), %rdi
callq 0x20f0
addq $0x8, %rbx
leaq 0x70(%rsp), %rsi
movq %rbx, %rdi
callq 0x97ba
leaq 0x10(%rsp), %rdi
callq 0x20f0
leaq 0x70(%rsp), %rdi
callq 0x9836
movl %ebp, %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
jmp 0x675b
jmp 0x6762
movq %rax, %rbx
leaq 0xb8(%rsp), %rdi
callq 0x9836
jmp 0x6756
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x20f0
jmp 0x6765
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x20f0
leaq 0x70(%rsp), %rdi
callq 0x9836
movq %rbx, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O2/AndrewAlbert[P]Compiler-Theory/SourceCode/parser.cpp
// Function: Parser::Integer()
bool Parser::Integer(){
	string val = token->ascii;
	if(CheckToken(TYPE_INTEGER)){
		generator->val2reg( val, TYPE_INTEGER );
		return true;
	}
	else return false;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %r14
movq 0x80(%rdi), %rsi
leaq 0x28(%rsp), %rdi
callq 0x2270
movq %r14, %rdi
movl $0x10a, %esi            # imm = 0x10A
callq 0x49b0
movl %eax, %ebx
testb %al, %al
je 0x8e7f
movq 0x98(%r14), %r14
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x2270
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movq %r14, %rsi
movl $0x10a, %ecx            # imm = 0x10A
callq 0xd864
leaq 0x48(%rsp), %rdi
callq 0x20f0
leaq 0x8(%rsp), %rdi
callq 0x20f0
leaq 0x28(%rsp), %rdi
callq 0x20f0
movl %ebx, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20f0
jmp 0x8ea5
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20f0
movq %rbx, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O2/AndrewAlbert[P]Compiler-Theory/SourceCode/parser.cpp
// Function: Parser::Float()
bool Parser::Float(){
	string val = token->ascii;
	if(CheckToken(TYPE_FLOAT)){
		generator->val2reg( val, TYPE_FLOAT );
		return true;
	}
	else return false;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %r14
movq 0x80(%rdi), %rsi
leaq 0x28(%rsp), %rdi
callq 0x2270
movq %r14, %rdi
movl $0x10b, %esi            # imm = 0x10B
callq 0x49b0
movl %eax, %ebx
testb %al, %al
je 0x8f27
movq 0x98(%r14), %r14
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x2270
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movq %r14, %rsi
movl $0x10b, %ecx            # imm = 0x10B
callq 0xd864
leaq 0x48(%rsp), %rdi
callq 0x20f0
leaq 0x8(%rsp), %rdi
callq 0x20f0
leaq 0x28(%rsp), %rdi
callq 0x20f0
movl %ebx, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20f0
jmp 0x8f4d
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20f0
movq %rbx, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O2/AndrewAlbert[P]Compiler-Theory/SourceCode/parser.cpp
// Function: Parser::String()
bool Parser::String(){
	string val = token->ascii;
	if(CheckToken(TYPE_STRING)){
		generator->val2reg( val, TYPE_STRING );
		return true;
	}
	else return false;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %r14
movq 0x80(%rdi), %rsi
leaq 0x28(%rsp), %rdi
callq 0x2270
movq %r14, %rdi
movl $0x10d, %esi            # imm = 0x10D
callq 0x49b0
movl %eax, %ebx
testb %al, %al
je 0x9417
movq 0x98(%r14), %r14
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x2270
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movq %r14, %rsi
movl $0x10d, %ecx            # imm = 0x10D
callq 0xd864
leaq 0x48(%rsp), %rdi
callq 0x20f0
leaq 0x8(%rsp), %rdi
callq 0x20f0
leaq 0x28(%rsp), %rdi
callq 0x20f0
movl %ebx, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20f0
jmp 0x943d
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20f0
movq %rbx, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O2/AndrewAlbert[P]Compiler-Theory/SourceCode/parser.cpp
// Function: Parser::Char()
bool Parser::Char(){
	string val = token->ascii;
	if(CheckToken(TYPE_CHAR)){
		generator->val2reg( val, TYPE_CHAR);
		return true;
	}
	else return false;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %r14
movq 0x80(%rdi), %rsi
leaq 0x28(%rsp), %rdi
callq 0x2270
movq %r14, %rdi
movl $0x10e, %esi            # imm = 0x10E
callq 0x49b0
movl %eax, %ebx
testb %al, %al
je 0x94bf
movq 0x98(%r14), %r14
leaq 0x8(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x2270
leaq 0x48(%rsp), %rdi
leaq 0x8(%rsp), %rdx
movq %r14, %rsi
movl $0x10e, %ecx            # imm = 0x10E
callq 0xd864
leaq 0x48(%rsp), %rdi
callq 0x20f0
leaq 0x8(%rsp), %rdi
callq 0x20f0
leaq 0x28(%rsp), %rdi
callq 0x20f0
movl %ebx, %eax
addq $0x68, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20f0
jmp 0x94e5
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
callq 0x20f0
movq %rbx, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O2/AndrewAlbert[P]Compiler-Theory/SourceCode/parser.cpp
// Function: Parser::Bool()
bool Parser::Bool(){
	string val = token->ascii;
	if(CheckToken(T_TRUE)){
		generator->val2reg( "1", TYPE_BOOL);
		return true;
	}
	else if(CheckToken(T_FALSE)){
		generator->val2reg( "0", TYPE_BOOL);
		return true;
	}
	else return false;
}

// Assembly:
pushq %rbx
subq $0xb0, %rsp
movq %rdi, %rbx
movq 0x80(%rdi), %rsi
leaq 0x50(%rsp), %rdi
callq 0x2270
movq %rbx, %rdi
movl $0x115, %esi            # imm = 0x115
callq 0x49b0
testb %al, %al
je 0x9570
movq 0x98(%rbx), %rbx
leaq 0x91dc(%rip), %rsi      # 0x1270f
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x36b8
leaq 0x90(%rsp), %rdi
leaq 0x30(%rsp), %rdx
movq %rbx, %rsi
movl $0x10c, %ecx            # imm = 0x10C
callq 0xd864
leaq 0x90(%rsp), %rdi
callq 0x20f0
leaq 0x30(%rsp), %rdi
jmp 0x95c4
movq %rbx, %rdi
movl $0x116, %esi            # imm = 0x116
callq 0x49b0
testb %al, %al
je 0x95cd
movq 0x98(%rbx), %rbx
leaq 0x9182(%rip), %rsi      # 0x12711
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x36b8
leaq 0x70(%rsp), %rdi
leaq 0x10(%rsp), %rdx
movq %rbx, %rsi
movl $0x10c, %ecx            # imm = 0x10C
callq 0xd864
leaq 0x70(%rsp), %rdi
callq 0x20f0
leaq 0x10(%rsp), %rdi
callq 0x20f0
movb $0x1, %bl
jmp 0x95cf
xorl %ebx, %ebx
leaq 0x50(%rsp), %rdi
callq 0x20f0
movl %ebx, %eax
addq $0xb0, %rsp
popq %rbx
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
jmp 0x95f8
jmp 0x9601
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x20f0
jmp 0x9604
jmp 0x9601
movq %rax, %rbx
leaq 0x50(%rsp), %rdi
callq 0x20f0
movq %rbx, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/AndrewAlbert[P]Compiler-Theory/SourceCode/scope.cpp
// Function: scope::scope(bool)
scope::scope(bool programScope){
	name = "";
	// Procedures allocate the first two bytes of their frame to pointers for stored FP and return address
	if( programScope ) totalBytes = 0;
	else totalBytes = 2;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
andl $0x0, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
leaq 0x38(%rdi), %rax
andl $0x0, 0x38(%rdi)
andq $0x0, 0x40(%rdi)
movq %rax, 0x48(%rdi)
movq %rax, 0x50(%rdi)
andq $0x0, 0x58(%rdi)
movl %esi, %ebp
leaq 0x60(%rdi), %r14
leaq 0x70(%rdi), %rax
movq %rax, 0x60(%rdi)
andq $0x0, 0x68(%rdi)
movb $0x0, 0x70(%rdi)
leaq 0x856c(%rip), %rsi      # 0x1293d
movq %r14, %rdi
callq 0x2370
xorb $0x1, %bpl
movzbl %bpl, %eax
addl %eax, %eax
movl %eax, 0x80(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
leaq 0x30(%rbx), %r12
movq %r14, %rdi
callq 0x20f0
movq %r12, %rdi
callq 0xaaa2
movq %rbx, %rdi
callq 0xaaa2
movq %r15, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O2/AndrewAlbert[P]Compiler-Theory/SourceCode/scope.cpp
// Function: scope::addSymbol(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool, scopeValue)
bool scope::addSymbol(string identifier, bool global, scopeValue value){
	map<string, scopeValue>::iterator it;
	it = localTable.find(identifier);
	if(it != localTable.end()) return false;
	else{
		if(value.type != TYPE_PROCEDURE){
			value.FPoffset = totalBytes;
			if( value.size > 0 ) totalBytes += value.size;
			else totalBytes += 1;
		}
		
		if(global) globalTable[identifier] = value;
		localTable[identifier] = value;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r14
movq %rdi, %r12
leaq 0x30(%rdi), %r15
movq %r15, %rdi
callq 0xab1e
leaq 0x38(%r12), %rcx
cmpq %rcx, %rax
je 0xa478
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x11e, (%rbx)          # imm = 0x11E
je 0xa4a1
movl 0x80(%r12), %eax
movl %eax, 0x44(%rbx)
movl 0x4(%rbx), %ecx
cmpl $0x2, %ecx
pushq $0x1
popq %rdx
cmovgel %ecx, %edx
addl %eax, %edx
movl %edx, 0x80(%r12)
testb %bpl, %bpl
je 0xa4bc
movq %r12, %rdi
movq %r14, %rsi
callq 0xa920
movq %rax, %rdi
movq %rbx, %rsi
callq 0xa986
movq %r15, %rdi
movq %r14, %rsi
callq 0xa920
movq %rax, %rdi
movq %rbx, %rsi
callq 0xa986
// File: /workspace/github_cpp_makefile_star2_O2/AndrewAlbert[P]Compiler-Theory/SourceCode/scope.cpp
// Function: scope::checkSymbol(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool)
bool scope::checkSymbol(string identifier, bool global){
	map<string, scopeValue>::iterator it;
	if(global){
		it = globalTable.find(identifier);
		if( it != globalTable.end() ) return true;
		else return false;
	}
	else{
		it = localTable.find(identifier);
		if( it != localTable.end() ) return true;
		else return false;
	}
}

// Assembly:
pushq %rbx
leaq 0x30(%rdi), %rax
leaq 0x38(%rdi), %rcx
leaq 0x8(%rdi), %rbx
testl %edx, %edx
cmoveq %rax, %rdi
cmoveq %rcx, %rbx
callq 0xab1e
cmpq %rbx, %rax
setne %al
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/AndrewAlbert[P]Compiler-Theory/SourceCode/scope.cpp
// Function: scope::getSymbol(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
scopeValue scope::getSymbol(string identifier){
	map<string, scopeValue>::iterator it;
	it = localTable.find(identifier);
	if(it != localTable.end())
		return it->second;
	else{
		scopeValue nullVal;
		nullVal.type = T_UNKNOWN;
		vector<scopeValue> nullVector;
		nullVal.arguments = nullVector;
		return nullVal;
	}
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x30(%rsi), %rdi
movq %rdx, %rsi
callq 0xab1e
addq $0x38, %r14
cmpq %r14, %rax
je 0xa529
addq $0x40, %rax
movq %rbx, %rdi
movq %rax, %rsi
callq 0x97e6
jmp 0xa568
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
andq $0x0, 0x18(%rbx)
leaq 0x30(%rbx), %rax
movq %rax, 0x20(%rbx)
andq $0x0, 0x28(%rbx)
leaq 0x8(%rbx), %rdi
movb $0x0, 0x30(%rbx)
movl $0x15e, (%rbx)          # imm = 0x15E
movq %rsp, %rsi
movaps %xmm0, (%rsi)
andq $0x0, 0x10(%rsi)
callq 0xa9c4
movq %rsp, %rdi
callq 0x9850
movq %rbx, %rax
addq $0x18, %rsp
popq %rbx
popq %r14
retq
movq %rax, %r14
movq %rsp, %rdi
callq 0x9850
movq %rbx, %rdi
callq 0x9836
movq %r14, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/AndrewAlbert[P]Compiler-Theory/SourceCode/scopeTracker.cpp
// Function: scopeTracker::newScope()
void scopeTracker::newScope(){
	if(curPtr != nullptr){
		//Add procedure scope
		tmpPtr = curPtr;
		curPtr = new scope(false);
		curPtr->prevScope = tmpPtr;
	}
	else{
		//Add program scope
		curPtr = new scope(true);
		curPtr->prevScope = tmpPtr;
		outermost = curPtr;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq (%rdi), %rax
testq %rax, %rax
je 0xb0fc
movq %rax, 0x8(%r14)
movl $0x90, %edi
callq 0x21e0
movq %rax, %rbx
movq %rax, %rdi
xorl %esi, %esi
callq 0xa374
movq %rbx, (%r14)
movq 0x8(%r14), %rax
movq %rax, 0x88(%rbx)
jmp 0xb126
movl $0x90, %edi
callq 0x21e0
movq %rax, %rbx
pushq $0x1
popq %rsi
movq %rax, %rdi
callq 0xa374
movq %rbx, (%r14)
movq 0x8(%r14), %rax
movq %rax, 0x88(%rbx)
movq %rbx, 0x10(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0xb130
movq %rax, %r14
movl $0x90, %esi
movq %rbx, %rdi
callq 0x21f0
movq %r14, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/AndrewAlbert[P]Compiler-Theory/SourceCode/scopeTracker.cpp
// Function: scopeTracker::exitScope()
void scopeTracker::exitScope(){
	if(curPtr != nullptr){
		if(debug) curPtr->printScope();
		tmpPtr = curPtr;
		curPtr = curPtr->prevScope;
		delete tmpPtr;
	}
	else if(debug) cout << "not in a scope!" << endl;
	return;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %rbx
movb 0x18(%rdi), %al
testq %rbx, %rbx
je 0xb193
movq %rdi, %r14
testb %al, %al
je 0xb169
movq %rbx, %rdi
callq 0xa58e
movq (%r14), %rbx
movq %rbx, 0x8(%r14)
movq 0x88(%rbx), %rax
movq %rax, (%r14)
movq %rbx, %rdi
callq 0xa41a
movl $0x90, %esi
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x21f0
testb %al, %al
je 0xb1b9
movq 0xfe32(%rip), %rdi      # 0x1afd0
leaq 0x77b9(%rip), %rsi      # 0x1295e
callq 0x21c0
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2100
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/AndrewAlbert[P]Compiler-Theory/SourceCode/scopeTracker.cpp
// Function: scopeTracker::addSymbol(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, scopeValue, bool)
bool scopeTracker::addSymbol(string identifier, scopeValue value, bool global){
	if(curPtr != nullptr){
		if(!curPtr->checkSymbol(identifier, false)){
			curPtr->addSymbol(identifier, global, value);
			return true;
		}
		else return false;
	}
	else return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq (%rdi), %r13
testq %r13, %r13
je 0xb212
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0x2270
movq %r13, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0xa4d2
movl %eax, %r13d
leaq 0x20(%rsp), %rdi
callq 0x20f0
testb %r13b, %r13b
je 0xb216
xorl %eax, %eax
jmp 0xb260
movq (%r12), %r12
movq %rsp, %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2270
leaq 0x40(%rsp), %rdi
movq %r14, %rsi
callq 0x97e6
movzbl %bpl, %edx
movq %rsp, %rbx
leaq 0x40(%rsp), %rcx
movq %r12, %rdi
movq %rbx, %rsi
callq 0xa444
leaq 0x40(%rsp), %rdi
callq 0x9836
movq %rsp, %rdi
callq 0x20f0
movb $0x1, %al
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x40(%rsp), %rdi
callq 0x9836
jmp 0xb286
jmp 0xb283
movq %rax, %r14
movq %rbx, %rdi
callq 0x20f0
movq %r14, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/AndrewAlbert[P]Compiler-Theory/SourceCode/scopeTracker.cpp
// Function: scopeTracker::prevAddSymbol(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, scopeValue, bool)
bool scopeTracker::prevAddSymbol(string identifier, scopeValue value, bool global){
	scope* prevPtr = curPtr->prevScope;
	if(prevPtr != nullptr){
		if(!prevPtr->checkSymbol(identifier, false)){
			prevPtr->addSymbol(identifier, global, value);
			return true;
		}
		else return false;
	}
	else return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq (%rdi), %rax
movq 0x88(%rax), %r14
testq %r14, %r14
je 0xb2ea
movl %ecx, %ebp
movq %rdx, %r15
movq %rsi, %r12
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
callq 0x2270
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0xa4d2
movl %eax, %r13d
leaq 0x20(%rsp), %rdi
callq 0x20f0
testb %r13b, %r13b
je 0xb2ee
xorl %eax, %eax
jmp 0xb334
movq %rsp, %rbx
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2270
leaq 0x40(%rsp), %rdi
movq %r15, %rsi
callq 0x97e6
movzbl %bpl, %edx
movq %rsp, %rbx
leaq 0x40(%rsp), %rcx
movq %r14, %rdi
movq %rbx, %rsi
callq 0xa444
leaq 0x40(%rsp), %rdi
callq 0x9836
movq %rsp, %rdi
callq 0x20f0
movb $0x1, %al
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x40(%rsp), %rdi
callq 0x9836
jmp 0xb35a
jmp 0xb357
movq %rax, %r14
movq %rbx, %rdi
callq 0x20f0
movq %r14, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/AndrewAlbert[P]Compiler-Theory/SourceCode/scopeTracker.cpp
// Function: scopeTracker::checkSymbol(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, scopeValue&, bool&)
bool scopeTracker::checkSymbol(string identifier, scopeValue &value, bool &global){
	// Ensure there is actuall a scope to check
	if(curPtr == nullptr) return false;
	
	// Check local symbols of current scope
	bool found = curPtr->checkSymbol(identifier, false);
	if(found){
		global = false;
		value = curPtr->getSymbol(identifier);
		return true;
	}
	else{
		found = outermost->checkSymbol(identifier, true);
		if(found){
			global = true;
			value = outermost->getSymbol(identifier);
			return true; 
		}
		else return false;
	}
	return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xc8, %rsp
movq (%rdi), %r13
testq %r13, %r13
je 0xb490
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
leaq 0x60(%rsp), %rbp
movq %rbp, %rdi
callq 0x2270
movq %r13, %rdi
movq %rbp, %rsi
xorl %edx, %edx
callq 0xa4d2
movl %eax, %ebp
leaq 0x60(%rsp), %rdi
callq 0x20f0
testb %bpl, %bpl
je 0xb40b
movb $0x0, (%r15)
movq (%r12), %r15
leaq 0x40(%rsp), %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x2270
leaq 0x80(%rsp), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xa4f6
leaq 0x80(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb52a
movq %r14, %rdi
callq 0x9836
leaq 0x40(%rsp), %rdi
jmp 0xb487
movq 0x10(%r12), %r13
leaq 0x20(%rsp), %rbp
movq %rbp, %rdi
movq %r14, %rsi
callq 0x2270
pushq $0x1
popq %rdx
movq %r13, %rdi
movq %rbp, %rsi
callq 0xa4d2
movl %eax, %ebp
leaq 0x20(%rsp), %rdi
callq 0x20f0
testb %bpl, %bpl
je 0xb490
movb $0x1, (%r15)
movq 0x10(%r12), %r15
movq %rsp, %r12
movq %r12, %rdi
movq %r14, %rsi
callq 0x2270
leaq 0x80(%rsp), %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0xa4f6
leaq 0x80(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xb52a
movq %r14, %rdi
callq 0x9836
movq %rsp, %rdi
callq 0x20f0
movb $0x1, %al
jmp 0xb492
xorl %eax, %eax
addq $0xc8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq %rsp, %rdi
jmp 0xb4c8
movq %rax, %rbx
leaq 0x20(%rsp), %rdi
jmp 0xb4c8
movq %rax, %rbx
leaq 0x40(%rsp), %rdi
jmp 0xb4c8
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x20f0
movq %rbx, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O2/AndrewAlbert[P]Compiler-Theory/SourceCode/codeGenerator.cpp
// Function: codeGenerator::~codeGenerator()
codeGenerator::~codeGenerator(){
	if( testOutFile() ){
		buildBranchTable();
		buildHeap();
		fprintf( oFile, "\nPROGRAM_END:\n" );
		footer();
		fclose( oFile );
	}
	else if( oFile != nullptr ){ 
			fclose( oFile );
	//Remove the generated file if there was an error
	}
	if( ContinueToGenerate == false && outputName.compare("") != 0 ) remove(outputName.c_str());
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0xb9e0
testb %al, %al
je 0xb8ea
movq %rbx, %rdi
callq 0xba00
movq %rbx, %rdi
callq 0xba60
movq 0x308(%rbx), %rcx
leaq 0x70f8(%rip), %rdi      # 0x129c6
pushq $0xe
popq %rsi
pushq $0x1
popq %rdx
callq 0x2380
movq %rbx, %rdi
callq 0xbb1e
movq 0x308(%rbx), %rdi
jmp 0xb8f6
movq 0x308(%rbx), %rdi
testq %rdi, %rdi
je 0xb8fb
callq 0x21d0
cmpb $0x0, 0x330(%rbx)
jne 0xb926
leaq 0x310(%rbx), %r14
leaq 0x702b(%rip), %rsi      # 0x1293d
movq %r14, %rdi
callq 0x20a0
testl %eax, %eax
je 0xb926
movq (%r14), %rdi
callq 0x2330
leaq 0x310(%rbx), %rdi
callq 0x20f0
leaq 0x2b8(%rbx), %rdi
callq 0xf5d8
leaq 0x250(%rbx), %rdi
callq 0xf630
leaq 0x230(%rbx), %rdi
callq 0x20f0
leaq 0x1d0(%rbx), %rdi
callq 0x9910
leaq 0x180(%rbx), %rdi
callq 0x9910
leaq 0x130(%rbx), %rdi
callq 0x9910
leaq 0xf0(%rbx), %rdi
callq 0xf782
leaq 0xc8(%rbx), %rdi
callq 0x20f0
leaq 0xa8(%rbx), %rdi
callq 0x20f0
leaq 0x88(%rbx), %rdi
callq 0x20f0
leaq 0x68(%rbx), %rdi
callq 0x20f0
leaq 0x48(%rbx), %rdi
callq 0x20f0
leaq 0x28(%rbx), %rdi
callq 0x20f0
addq $0x8, %rbx
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x20f0
movq %rax, %rdi
callq 0x3647
// File: /workspace/github_cpp_makefile_star2_O2/AndrewAlbert[P]Compiler-Theory/SourceCode/codeGenerator.cpp
// Function: codeGenerator::buildBranchTable()
bool codeGenerator::buildBranchTable(){
	fprintf( oFile, "\n   goto PROGRAM_END;\n" );
	fprintf( oFile, "\nBRANCH_TABLE:\n" );
	if( !branchTable.empty() ){
		createEntry(0, branchTable.size() - 1);
	}
	return true;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x308(%rdi), %rcx
leaq 0x79d3(%rip), %rdi      # 0x133e8
pushq $0x16
popq %rsi
pushq $0x1
popq %r14
movq %r14, %rdx
callq 0x2380
movq 0x308(%rbx), %rcx
leaq 0x79cd(%rip), %rdi      # 0x133ff
pushq $0xf
popq %rsi
movq %r14, %rdx
callq 0x2380
movq 0x118(%rbx), %rdx
testq %rdx, %rdx
je 0xba55
decl %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0xf338
movb $0x1, %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/AndrewAlbert[P]Compiler-Theory/SourceCode/codeGenerator.cpp
// Function: codeGenerator::buildHeap()
void codeGenerator::buildHeap(){
	fprintf( oFile, "\nBUILD_HEAP:\n" );
	while( string_heap.size() > 0 ){
		stringEntry = string_heap.front();
		string_heap.pop();
		fprintf( oFile, "   strcpy((char*)&MM[%d], %s);\n", stringEntry.MMlocation, stringEntry.contents.c_str() );
		fprintf( oFile, "   TP_reg = %d;\n", stringEntry.MMlocation );
	}
	fprintf( oFile, "   goto Label_0_Begin_Program;\n" );
	return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
movq 0x308(%rdi), %rcx
leaq 0x73f3(%rip), %rdi      # 0x12e6d
pushq $0xd
popq %rsi
pushq $0x1
popq %rdx
callq 0x2380
leaq 0x250(%rbx), %r14
leaq 0x228(%rbx), %r15
leaq 0x73e1(%rip), %r12      # 0x12e7b
leaq 0x73fa(%rip), %r13      # 0x12e9b
movq %r14, %rdi
callq 0xfdf4
testq %rax, %rax
je 0xbafc
movq 0x260(%rbx), %rsi
movq %r15, %rdi
callq 0xf570
movq %r14, %rdi
callq 0xff94
movq 0x308(%rbx), %rdi
movl 0x228(%rbx), %edx
movq 0x230(%rbx), %rcx
movq %r12, %rsi
xorl %eax, %eax
callq 0x2280
movq 0x308(%rbx), %rdi
movl 0x228(%rbx), %edx
movq %r13, %rsi
xorl %eax, %eax
callq 0x2280
jmp 0xbaa1
movq 0x308(%rbx), %rcx
leaq 0x73a2(%rip), %rdi      # 0x12eac
pushq $0x1f
popq %rsi
pushq $0x1
popq %rdx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2380
// File: /workspace/github_cpp_makefile_star2_O2/AndrewAlbert[P]Compiler-Theory/SourceCode/codeGenerator.cpp
// Function: codeGenerator::attachOutputFile(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
bool codeGenerator::attachOutputFile(string filename){
	outputName = filename;
	oFile = fopen( filename.c_str(), "w" );
	if( testOutFile() ){
		header();
		return true;
	}
	else{
		perror("Failed to open output file for writing.");
		fclose( oFile );
		ContinueToGenerate = false;
		return false;
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
addq $0x310, %rdi            # imm = 0x310
callq 0x2120
movq (%r14), %rdi
leaq 0x6e43(%rip), %rsi      # 0x129d5
callq 0x2220
movq %rax, 0x308(%rbx)
movq %rbx, %rdi
callq 0xb9e0
movl %eax, %ebp
testb %al, %al
je 0xbbbb
movq %rbx, %rdi
callq 0xbbdc
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x6e15(%rip), %rdi      # 0x129d7
callq 0x2180
movq 0x308(%rbx), %rdi
callq 0x21d0
movb $0x0, 0x330(%rbx)
jmp 0xbbb4
// File: /workspace/github_cpp_makefile_star2_O2/AndrewAlbert[P]Compiler-Theory/SourceCode/codeGenerator.cpp
// Function: codeGenerator::comment(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool)
void codeGenerator::comment(string str, bool multi_line){
	if( multi_line ){
		fprintf( oFile, "\n" );
		fprintf( oFile, "// %s\n", str.c_str() );
		fprintf( oFile, "\n" );
	}
	else fprintf( oFile, "// %s\n", str.c_str() );
	return;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %r14
movq 0x308(%rdi), %rax
testl %edx, %edx
je 0xbfe4
movq %rdi, %rbx
pushq $0xa
popq %rbp
movl %ebp, %edi
movq %rax, %rsi
callq 0x2250
movq 0x308(%rbx), %rdi
movq (%r14), %rdx
leaq 0x6a34(%rip), %rsi      # 0x129ff
xorl %eax, %eax
callq 0x2280
movq 0x308(%rbx), %rsi
movl %ebp, %edi
popq %rbx
popq %r14
popq %rbp
jmp 0x2250
movq (%r14), %rdx
leaq 0x6a11(%rip), %rsi      # 0x129ff
movq %rax, %rdi
xorl %eax, %eax
popq %rbx
popq %r14
popq %rbp
jmp 0x2280
// File: /workspace/github_cpp_makefile_star2_O2/AndrewAlbert[P]Compiler-Theory/SourceCode/codeGenerator.cpp
// Function: codeGenerator::typeString[abi:cxx11](int)
string codeGenerator::typeString( int type ){
	switch( type ){
		case TYPE_CHAR: 
			return "char";
		case TYPE_INTEGER:
			return "int";
		case TYPE_FLOAT:
			return"float";
		case TYPE_BOOL:
			return "int";
		case TYPE_STRING: 
			return "char*";
		default: 
			return "ERROR:";
	}
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
addl $0xfffffef6, %edx       # imm = 0xFFFFFEF6
cmpl $0x4, %edx
ja 0xc88b
leaq 0x6134(%rip), %rax      # 0x12970
movslq (%rax,%rdx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
leaq 0x64f0(%rip), %rsi      # 0x12d3c
leaq 0xe(%rsp), %rdx
jmp 0xc897
leaq 0x64dd(%rip), %rsi      # 0x12d37
leaq 0xf(%rsp), %rdx
jmp 0xc897
leaq 0x64d4(%rip), %rsi      # 0x12d3c
leaq 0xc(%rsp), %rdx
jmp 0xc897
leaq 0x64d0(%rip), %rsi      # 0x12d46
leaq 0xb(%rsp), %rdx
jmp 0xc897
leaq 0x64bc(%rip), %rsi      # 0x12d40
leaq 0xd(%rsp), %rdx
jmp 0xc897
leaq 0x64ba(%rip), %rsi      # 0x12d4c
leaq 0xa(%rsp), %rdx
movq %rbx, %rdi
callq 0x36b8
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/AndrewAlbert[P]Compiler-Theory/SourceCode/codeGenerator.cpp
// Function: codeGenerator::pushStack(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char, int)
void codeGenerator::pushStack( string value, char stackID, int type ){
	if( !ShouldGenerate() ) return;
	switch( stackID ){
		case 'L':
			leftStack.push( value );
			break;
		case 'E':
			exprStack.push( value );
			if( type == TYPE_FLOAT ) freg_in_use++;
			else ireg_in_use++;
			break;
		case 'R':
			rightStack.push( value );
			break;
		default:
			cout << "Not a valid expression stack!\n";
			break;
	}
	return;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
cmpb $0x1, 0x330(%rdi)
jne 0xc924
movq %rdi, %rbx
movsbl %dl, %eax
cmpl $0x45, %eax
je 0xc8e7
cmpl $0x52, %eax
je 0xc8d2
cmpl $0x4c, %eax
jne 0xc905
addq $0x1d0, %rbx            # imm = 0x1D0
jmp 0xc8d9
addq $0x180, %rbx            # imm = 0x180
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xfbc6
movl %ecx, %ebp
leaq 0x130(%rbx), %rdi
callq 0xfbc6
cmpl $0x10b, %ebp            # imm = 0x10B
jne 0xc91e
incl 0x124(%rbx)
jmp 0xc924
movq 0xe6c4(%rip), %rdi      # 0x1afd0
leaq 0x6440(%rip), %rsi      # 0x12d53
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x21c0
incl 0x120(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/AndrewAlbert[P]Compiler-Theory/SourceCode/codeGenerator.cpp
// Function: codeGenerator::NotOnRegister(int, int)
void codeGenerator::NotOnRegister( int type, int size ){
	if( !ShouldGenerate() ) return;
	string reg;
	comment("Not Operation on Register");
	
	//Ensure size is at least 1 for the loops
	if( size == 0 ) size++;
	
	for( int i = 0; i < size; i++ ){
		reg = popStack('E', type);
		pushStack( reg, 'R', type );
	}
	for( int i = 0; i < size; i++ ){
		reg = popStack('R', type);
		pushStack(reg, 'E', type);
		if( type == TYPE_BOOL ){
			// boolean not
			fprintf( oFile, "   %s = !( %s );\n", reg.c_str(), reg.c_str() );
		}
		else if( type == TYPE_INTEGER ){
			// bitwise not
			fprintf( oFile, "   %s = ~( %s );\n", reg.c_str(), reg.c_str() );
		}
	}
	return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
cmpb $0x1, 0x330(%rdi)
jne 0xd81c
movl %edx, %r15d
movl %esi, %ebp
movq %rdi, %r14
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq 0x574d(%rip), %rsi      # 0x12e07
leaq 0x88(%rsp), %rdi
leaq 0x48(%rsp), %rdx
callq 0x36b8
leaq 0x88(%rsp), %rbx
xorl %r12d, %r12d
movq %r14, %rdi
movq %rbx, %rsi
xorl %edx, %edx
callq 0xbf98
movq %rbx, %rdi
callq 0x20f0
cmpl $0x1, %r15d
adcl $0x0, %r15d
leaq 0x180(%r14), %rax
movq %rax, (%rsp)
testl %r15d, %r15d
cmovlel %r12d, %r15d
leaq 0x48(%rsp), %r12
movl %r15d, %ebx
subl $0x1, %ebx
jb 0xd76c
movq %r12, %rdi
movq %r14, %rsi
pushq $0x45
popq %rdx
movl %ebp, %ecx
callq 0xc92c
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x2240
movq %r12, %rdi
callq 0x20f0
leaq 0x28(%rsp), %rdi
movq %r13, %rsi
callq 0x2270
cmpb $0x1, 0x330(%r14)
jne 0xd760
movq (%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xfbc6
leaq 0x28(%rsp), %rdi
callq 0x20f0
jmp 0xd70e
leaq 0x48(%rsp), %rbx
leaq 0x8(%rsp), %r13
leaq 0x68(%rsp), %r12
subl $0x1, %r15d
jb 0xd812
movq %rbx, %rdi
movq %r14, %rsi
pushq $0x52
popq %rdx
movl %ebp, %ecx
callq 0xc92c
movq %r13, %rdi
movq %rbx, %rsi
callq 0x2240
movq %rbx, %rdi
callq 0x20f0
movq %r12, %rdi
movq %r13, %rsi
callq 0x2270
movq %r14, %rdi
movq %r12, %rsi
pushq $0x45
popq %rdx
movl %ebp, %ecx
callq 0xc8a8
movq %r12, %rdi
callq 0x20f0
cmpl $0x10a, %ebp            # imm = 0x10A
je 0xd7f0
cmpl $0x10c, %ebp            # imm = 0x10C
jne 0xd77b
movq 0x308(%r14), %rdi
movq 0x8(%rsp), %rcx
leaq 0x5633(%rip), %rsi      # 0x12e21
jmp 0xd803
movq 0x308(%r14), %rdi
movq 0x8(%rsp), %rcx
leaq 0x5630(%rip), %rsi      # 0x12e33
movq %rcx, %rdx
xorl %eax, %eax
callq 0x2280
jmp 0xd77b
leaq 0x8(%rsp), %rdi
callq 0x20f0
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xd84f
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
jmp 0xd846
jmp 0xd84f
jmp 0xd84f
movq %rax, %rbx
leaq 0x68(%rsp), %rdi
callq 0x20f0
jmp 0xd852
jmp 0xd84f
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20f0
movq %rbx, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/AndrewAlbert[P]Compiler-Theory/SourceCode/codeGenerator.cpp
// Function: codeGenerator::val2reg(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
string codeGenerator::val2reg( string val, int type ){
	if( !ShouldGenerate() ) return "";
	savedArgument.size = 0;
	savedArgument.type = type;
	savedArgument.indirect = false;
	savedArgument.set = true;
	savedArgument.isGlobal = false;
	
	string reg;
	comment("Constant Value to Register");
	reg = newRegister( type );

	pushStack( reg, 'E', type );

	if(type == TYPE_STRING){
		val = to_string( AddStringHeap( val ) );
	}
	fprintf( oFile, "   %s = %s;\n", reg.c_str(), val.c_str() );
	return reg;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
cmpb $0x0, 0x330(%rsi)
je 0xd99a
movl %ecx, %ebp
movq %rdx, %r14
movq %rsi, %r15
andl $0x0, 0x2a8(%rsi)
movl %ecx, 0x2a4(%rsi)
andw $0x0, 0x2b4(%rsi)
movb $0x1, 0x2b6(%rsi)
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
andq $0x0, 0x8(%rbx)
movb $0x0, 0x10(%rbx)
leaq 0x5587(%rip), %rsi      # 0x12e45
leaq 0x60(%rsp), %rdi
movq %rsp, %rdx
callq 0x36b8
leaq 0x60(%rsp), %r12
movq %r15, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0xbf98
movq %r12, %rdi
callq 0x20f0
movq %rsp, %rdi
movq %r15, %rsi
movl %ebp, %edx
callq 0xd4fe
movq %rsp, %r12
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2240
movq %r12, %rdi
callq 0x20f0
leaq 0x40(%rsp), %rdi
movq %rbx, %rsi
callq 0x2270
leaq 0x40(%rsp), %rsi
pushq $0x45
popq %rdx
movq %r15, %rdi
movl %ebp, %ecx
callq 0xc8a8
leaq 0x40(%rsp), %rdi
callq 0x20f0
cmpl $0x10d, %ebp            # imm = 0x10D
jne 0xd97d
leaq 0x20(%rsp), %rdi
movq %r14, %rsi
callq 0x2270
leaq 0x20(%rsp), %rsi
movq %r15, %rdi
callq 0xd9f2
movq %rsp, %rdi
movl %eax, %esi
callq 0x96b3
movq %rsp, %r12
movq %r14, %rdi
movq %r12, %rsi
callq 0x2240
movq %r12, %rdi
callq 0x20f0
leaq 0x20(%rsp), %rdi
callq 0x20f0
movq 0x308(%r15), %rdi
movq (%rbx), %rdx
movq (%r14), %rcx
leaq 0x54cf(%rip), %rsi      # 0x12e60
xorl %eax, %eax
callq 0x2280
jmp 0xd9ac
leaq 0x4f9c(%rip), %rsi      # 0x1293d
movq %rsp, %rdx
movq %rbx, %rdi
callq 0x36b8
movq %rbx, %rax
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0xd9de
movq %rax, %r14
leaq 0x20(%rsp), %rdi
jmp 0xd9d3
movq %rax, %r14
leaq 0x40(%rsp), %rdi
callq 0x20f0
jmp 0xd9e1
jmp 0xd9de
jmp 0xd9de
movq %rax, %r14
movq %rbx, %rdi
callq 0x20f0
movq %r14, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O2/AndrewAlbert[P]Compiler-Theory/SourceCode/codeGenerator.cpp
// Function: codeGenerator::AddStringHeap(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int codeGenerator::AddStringHeap( string str ){
	if( !ShouldGenerate() ) return -1;
	HeapSize += ( str.size() + 1);
	stringEntry.MMlocation = HeapSize;
	stringEntry.contents = str;
	string_heap.push(stringEntry);
	return HeapSize;
}

// Assembly:
cmpb $0x1, 0x330(%rdi)
jne 0xda4b
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl 0x8(%rsi), %eax
movl 0x220(%rdi), %ecx
leal 0x1(%rax,%rcx), %eax
movl %eax, 0x220(%rdi)
leaq 0x228(%rdi), %r14
movl %eax, 0x228(%rdi)
addq $0x230, %rdi            # imm = 0x230
callq 0x2120
leaq 0x250(%rbx), %rdi
movq %r14, %rsi
callq 0xfd04
movl 0x220(%rbx), %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
pushq $-0x1
popq %rax
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/AndrewAlbert[P]Compiler-Theory/SourceCode/codeGenerator.cpp
// Function: codeGenerator::NegateTopRegisters(int, int)
void codeGenerator::NegateTopRegisters( int type, int size ){
	if( !ShouldGenerate() ) return;
	string reg;
	int i;
	// Ensure size is at least 1 for loops
	if( size == 0 ) size++;
	
	for( i = 0; i < size; i++ ){
		reg = popStack('E', type);
		pushStack( reg, 'L', type );
	}
	for( i = 0; i < size; i++ ){
		reg = popStack('L', type);
		pushStack( reg, 'E', type );
		fprintf( oFile, "   %s = -%s;\n", reg.c_str(), reg.c_str() );
	}
	return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
cmpb $0x1, 0x330(%rdi)
jne 0xdb88
movl %esi, %ebx
movq %rdi, %r14
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
andq $0x0, -0x8(%rax)
movb $0x0, (%rax)
cmpl $0x1, %edx
adcl $0x0, %edx
leaq 0x1d0(%rdi), %rax
movq %rax, (%rsp)
xorl %r15d, %r15d
testl %edx, %edx
cmovgl %edx, %r15d
leaq 0x68(%rsp), %r12
movl %r15d, %ebp
subl $0x1, %ebp
jb 0xdb04
movq %r12, %rdi
movq %r14, %rsi
pushq $0x45
popq %rdx
movl %ebx, %ecx
callq 0xc92c
leaq 0x8(%rsp), %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0x2240
movq %r12, %rdi
callq 0x20f0
leaq 0x28(%rsp), %rdi
movq %r13, %rsi
callq 0x2270
cmpb $0x1, 0x330(%r14)
jne 0xdaf8
movq (%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xfbc6
leaq 0x28(%rsp), %rdi
callq 0x20f0
jmp 0xdaa6
leaq 0x68(%rsp), %rbp
leaq 0x8(%rsp), %r12
leaq 0x48(%rsp), %r13
subl $0x1, %r15d
jb 0xdb7e
movq %rbp, %rdi
movq %r14, %rsi
pushq $0x4c
popq %rdx
movl %ebx, %ecx
callq 0xc92c
movq %r12, %rdi
movq %rbp, %rsi
callq 0x2240
movq %rbp, %rdi
callq 0x20f0
movq %r13, %rdi
movq %r12, %rsi
callq 0x2270
movq %r14, %rdi
movq %r13, %rsi
pushq $0x45
popq %rdx
movl %ebx, %ecx
callq 0xc8a8
movq %r13, %rdi
callq 0x20f0
movq 0x308(%r14), %rdi
movq 0x8(%rsp), %rcx
leaq 0x535a(%rip), %rsi      # 0x12ecc
movq %rcx, %rdx
xorl %eax, %eax
callq 0x2280
jmp 0xdb13
leaq 0x8(%rsp), %rdi
callq 0x20f0
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq 0x28(%rsp), %rdi
jmp 0xdbb0
jmp 0xdbb9
jmp 0xdbb9
movq %rax, %rbx
leaq 0x48(%rsp), %rdi
callq 0x20f0
jmp 0xdbbc
jmp 0xdbb9
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20f0
movq %rbx, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/AndrewAlbert[P]Compiler-Theory/SourceCode/codeGenerator.cpp
// Function: codeGenerator::setProcedurePointers(int)
void codeGenerator::setProcedurePointers( int frameSize ){
	if( !ShouldGenerate() ) return;
	comment( "Set FP and SP using the caller's FP/SP values and the new frame size" );
	fprintf( oFile, "   FP_reg = SP_reg;\n" );
	fprintf( oFile, "   SP_reg = FP_reg + %d;\n", frameSize);
	return;
}

// Assembly:
cmpb $0x1, 0x330(%rdi)
jne 0xec1e
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movl %esi, %ebx
movq %rdi, %r14
leaq 0x43ff(%rip), %rsi      # 0x12fbd
leaq 0x10(%rsp), %r15
leaq 0xf(%rsp), %rdx
movq %r15, %rdi
callq 0x36b8
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0xbf98
movq %r15, %rdi
callq 0x20f0
movq 0x308(%r14), %rcx
leaq 0x440f(%rip), %rdi      # 0x13002
pushq $0x14
popq %rsi
pushq $0x1
popq %rdx
callq 0x2380
movq 0x308(%r14), %rdi
leaq 0x440b(%rip), %rsi      # 0x13017
movl %ebx, %edx
xorl %eax, %eax
callq 0x2280
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/AndrewAlbert[P]Compiler-Theory/SourceCode/codeGenerator.cpp
// Function: codeGenerator::callProcedure(scopeValue, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void codeGenerator::callProcedure( scopeValue procValue, string id ){
	if( !ShouldGenerate() ) return;
	
	comment( "Call procedure" );
	fprintf( oFile, "   MM[SP_reg] = FP_reg;\n" );
	fprintf( oFile, "   MM[SP_reg + 1] = %d;\n", call_count );
	fprintf( oFile, "   goto %s;\n", procValue.CallLabel.c_str() );
	
	string retLabel = newReturnLabel(id);
	placeLabel( retLabel );
	return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x88, %rsp
cmpb $0x1, 0x330(%rdi)
jne 0xed1d
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x43e6(%rip), %rsi      # 0x13031
leaq 0x68(%rsp), %r12
leaq 0x8(%rsp), %rdx
movq %r12, %rdi
callq 0x36b8
movq %rbx, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0xbf98
movq %r12, %rdi
callq 0x20f0
movq 0x308(%rbx), %rcx
leaq 0x43c0(%rip), %rdi      # 0x13040
pushq $0x18
popq %rsi
pushq $0x1
popq %rdx
callq 0x2380
movq 0x308(%rbx), %rdi
movl 0xe8(%rbx), %edx
leaq 0x43ba(%rip), %rsi      # 0x13059
xorl %eax, %eax
callq 0x2280
movq 0x308(%rbx), %rdi
movq 0x20(%r15), %rdx
leaq 0x43ba(%rip), %rsi      # 0x13072
xorl %eax, %eax
callq 0x2280
leaq 0x48(%rsp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x2270
leaq 0x8(%rsp), %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0xed42
leaq 0x48(%rsp), %rdi
callq 0x20f0
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %r15
movq %r15, %rsi
callq 0x2270
leaq 0x28(%rsp), %r14
movq %rbx, %rdi
movq %r14, %rsi
callq 0xeb7e
movq %r14, %rdi
callq 0x20f0
leaq 0x8(%rsp), %rdi
callq 0x20f0
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
jmp 0xed2e
movq %rax, %rbx
movq %r15, %rdi
callq 0x20f0
movq %rbx, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O2/AndrewAlbert[P]Compiler-Theory/SourceCode/codeGenerator.cpp
// Function: codeGenerator::newReturnLabel(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string codeGenerator::newReturnLabel( string prefix ){
	string label = "Label_Return_" + to_string(call_count) + "_" + prefix;
	branchTable[call_count] = label;
	call_count++;
	return label;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movl 0xe8(%rsi), %esi
leaq 0x48(%rsp), %r12
movq %r12, %rdi
callq 0x96b3
leaq 0x466a(%rip), %rsi      # 0x133da
leaq 0x8(%rsp), %rdi
movq %r12, %rdx
callq 0x968f
leaq 0x29c9(%rip), %rdx      # 0x1174d
leaq 0x28(%rsp), %rdi
leaq 0x8(%rsp), %rsi
callq 0x9670
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x9651
leaq 0xe8(%r14), %r15
leaq 0x28(%rsp), %rdi
callq 0x20f0
leaq 0x8(%rsp), %rdi
callq 0x20f0
leaq 0x48(%rsp), %rdi
callq 0x20f0
addq $0xf0, %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0xf58a
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2120
incl (%r15)
movq %rbx, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x20f0
jmp 0xee09
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x20f0
jmp 0xee18
movq %rax, %r14
leaq 0x48(%rsp), %rdi
jmp 0xee25
movq %rax, %r14
movq %rbx, %rdi
callq 0x20f0
movq %r14, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O2/AndrewAlbert[P]Compiler-Theory/SourceCode/codeGenerator.cpp
// Function: codeGenerator::ProcedureReturn()
void codeGenerator::ProcedureReturn(){
	if( !ShouldGenerate() ) return;
	comment( "Procedure return" );
	fprintf( oFile, "   TP_reg = MM[FP_reg + 1];\n" );
	fprintf( oFile, "   FP_reg = MM[FP_reg];\n" );
	fprintf( oFile, "   goto BRANCH_TABLE;\n" );
	return;
}

// Assembly:
cmpb $0x1, 0x330(%rdi)
jne 0xeecd
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x422f(%rip), %rsi      # 0x1307f
leaq 0x8(%rsp), %r14
leaq 0x7(%rsp), %rdx
movq %r14, %rdi
callq 0x36b8
movq %rbx, %rdi
movq %r14, %rsi
xorl %edx, %edx
callq 0xbf98
movq %r14, %rdi
callq 0x20f0
movq 0x308(%rbx), %rcx
leaq 0x420b(%rip), %rdi      # 0x13090
pushq $0x1c
popq %rsi
pushq $0x1
popq %r14
movq %r14, %rdx
callq 0x2380
movq 0x308(%rbx), %rcx
leaq 0x420b(%rip), %rdi      # 0x130ad
pushq $0x18
popq %rsi
movq %r14, %rdx
callq 0x2380
movq 0x308(%rbx), %rcx
leaq 0x420b(%rip), %rdi      # 0x130c6
pushq $0x16
popq %rsi
movq %r14, %rdx
callq 0x2380
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O2/AndrewAlbert[P]Compiler-Theory/SourceCode/codeGenerator.cpp
// Function: codeGenerator::condBranch(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void codeGenerator::condBranch( string labelTrue, string labelFalse ){
	if( !ShouldGenerate() ) return;
	string cond = popStack('E', TYPE_BOOL);
	comment("Conditional branch");
	// goto true condition
	fprintf( oFile, "   if( %s ) goto %s;\n", cond.c_str(), labelTrue.c_str() );
	// goto else condition if one exists
	if( labelFalse.compare("") != 0 ) fprintf( oFile, "   goto %s;\n", labelFalse.c_str() );
	return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
cmpb $0x1, 0x330(%rdi)
jne 0xefa8
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x8(%rsp), %rdi
pushq $0x45
popq %rdx
movq %r14, %rsi
movl $0x10c, %ecx            # imm = 0x10C
callq 0xc92c
leaq 0x41b0(%rip), %rsi      # 0x130dd
leaq 0x28(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x36b8
leaq 0x28(%rsp), %r12
movq %r14, %rdi
movq %r12, %rsi
xorl %edx, %edx
callq 0xbf98
movq %r12, %rdi
callq 0x20f0
movq 0x308(%r14), %rdi
movq 0x8(%rsp), %rdx
movq (%r15), %rcx
leaq 0x4184(%rip), %rsi      # 0x130f0
xorl %eax, %eax
callq 0x2280
leaq 0x39c3(%rip), %rsi      # 0x1293d
movq %rbx, %rdi
callq 0x20a0
testl %eax, %eax
je 0xef9e
movq 0x308(%r14), %rdi
movq (%rbx), %rdx
leaq 0x40db(%rip), %rsi      # 0x13072
xorl %eax, %eax
callq 0x2280
leaq 0x8(%rsp), %rdi
callq 0x20f0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x20f0
movq %rbx, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O2/AndrewAlbert[P]Compiler-Theory/SourceCode/codeGenerator.cpp
// Function: codeGenerator::branch(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void codeGenerator::branch( string label ){
	if( !ShouldGenerate() ) return;
	comment("Unconditional branch");
	fprintf( oFile, "   goto %s;\n", label.c_str() );
	return;
}

// Assembly:
cmpb $0x1, 0x330(%rdi)
jne 0xf031
pushq %r15
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0x411d(%rip), %rsi      # 0x13106
leaq 0x10(%rsp), %r15
leaq 0xf(%rsp), %rdx
movq %r15, %rdi
callq 0x36b8
movq %r14, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0xbf98
movq %r15, %rdi
callq 0x20f0
movq 0x308(%r14), %rdi
movq (%rbx), %rdx
leaq 0x4051(%rip), %rsi      # 0x13072
xorl %eax, %eax
callq 0x2280
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/AndrewAlbert[P]Compiler-Theory/SourceCode/codeGenerator.cpp
// Function: codeGenerator::setArgument(scopeValue, bool, int, bool)
void codeGenerator::setArgument( scopeValue value, bool isGlobal, int index, bool indirect ){
	if( !ShouldGenerate() ) return;
	savedArgument.paramType = value.paramType;
	savedArgument.type = value.type;
	savedArgument.size = value.size;
	savedArgument.index = index;
	savedArgument.indirect = indirect;
	savedArgument.offset = value.FPoffset;
	savedArgument.isGlobal = isGlobal;
	savedArgument.set = true;
	return;
}

// Assembly:
cmpb $0x1, 0x330(%rdi)
jne 0xf095
movl 0x40(%rsi), %eax
movl %eax, 0x2a0(%rdi)
movq (%rsi), %rax
movq %rax, 0x2a4(%rdi)
movl %ecx, 0x2ac(%rdi)
movb %r8b, 0x2b4(%rdi)
movl 0x44(%rsi), %eax
movl %eax, 0x2b0(%rdi)
movb %dl, 0x2b5(%rdi)
movb $0x1, 0x2b6(%rdi)
retq
// File: /workspace/github_cpp_makefile_star2_O2/AndrewAlbert[P]Compiler-Theory/SourceCode/codeGenerator.cpp
// Function: codeGenerator::pushArgument(int&, int)
void codeGenerator::pushArgument( int &SPoffset, int paramType){
	if( !ShouldGenerate() ) return;
	savedArgument.paramType = paramType;
	if( savedArgument.paramType == TYPE_PARAM_IN || savedArgument.paramType == TYPE_PARAM_INOUT ){
		argListStack.push( savedArgument );
	}
	else if( savedArgument.paramType == TYPE_PARAM_OUT) argListStack.push( savedArgument );

	if(savedArgument.paramType == TYPE_PARAM_IN || savedArgument.paramType == TYPE_PARAM_INOUT){
		comment("Push argument");
		if( savedArgument.index < 0 ){
			reg2mm(savedArgument.type, savedArgument.type, savedArgument.size, savedArgument.size, SPoffset, savedArgument.isGlobal, false, TYPE_INTEGER, true);
		}
		else{
			reg2mm(savedArgument.type, savedArgument.type, 1, 1, SPoffset, savedArgument.isGlobal, false, TYPE_INTEGER, true);
		}
	}

	if( savedArgument.size > 1 ) SPoffset += savedArgument.size;
	else SPoffset += 1;
	
	resetArgument();
	return;
}

// Assembly:
cmpb $0x1, 0x330(%rdi)
jne 0xf1ad
pushq %r15
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movl %edx, 0x2a0(%rdi)
leal -0x11f(%rdx), %eax
cmpl $0x2, %eax
ja 0xf0dc
leaq 0x2a0(%rbx), %rsi
leaq 0x2b8(%rbx), %rdi
callq 0x10006
movl 0x2a0(%rbx), %edx
cmpl $0x121, %edx            # imm = 0x121
je 0xf0f0
cmpl $0x11f, %edx            # imm = 0x11F
jne 0xf18a
leaq 0x4024(%rip), %rsi      # 0x1311b
leaq 0x50(%rsp), %r15
leaq 0xf(%rsp), %rdx
movq %r15, %rdi
callq 0x36b8
movq %rbx, %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0xbf98
movq %r15, %rdi
callq 0x20f0
cmpl $0x0, 0x2ac(%rbx)
movl 0x2a4(%rbx), %ecx
js 0xf147
movl (%r14), %eax
movzbl 0x2b5(%rbx), %r10d
subq $0x8, %rsp
leaq 0x18(%rsp), %r15
pushq $0x1
popq %r8
jmp 0xf162
movl 0x2a8(%rbx), %r8d
movl (%r14), %eax
movzbl 0x2b5(%rbx), %r10d
subq $0x8, %rsp
leaq 0x38(%rsp), %r15
movq %r15, %rdi
movq %rbx, %rsi
movl %ecx, %edx
movl %r8d, %r9d
pushq $0x1
pushq $0x10a                  # imm = 0x10A
pushq $0x0
pushq %r10
pushq %rax
callq 0xe322
addq $0x30, %rsp
movq %r15, %rdi
callq 0x20f0
movl 0x2a8(%rbx), %eax
cmpl $0x2, %eax
pushq $0x1
popq %rcx
cmovgel %eax, %ecx
addl %ecx, (%r14)
movq %rbx, %rdi
callq 0xf032
addq $0x70, %rsp
popq %rbx
popq %r14
popq %r15
retq