LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/AsherGlick[P]CommentHeader/source/main.cpp
// Function: stripTrailingSpaces(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
string stripTrailingSpaces(string withTrailingSpaces) {
  string withoutTrailingSpaces = "";
  int cutoff = withTrailingSpaces.size()-1;
  for (; cutoff >= 0; cutoff--) {
    if (withTrailingSpaces[cutoff] != ' ') {
      break;
    }
  }
  for (int i = 0; i <= cutoff; i++) {
    withoutTrailingSpaces += withTrailingSpaces[i];
  }

  return withoutTrailingSpaces;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %r15
movq %r15, (%rdi)
leaq 0x6364(%rip), %rdx      # 0xfbd9
movq %rdx, %rsi
callq 0x7590
movq 0x8(%r14), %rcx
movl %ecx, %eax
decl %ecx
cmpl $-0x1, %ecx
movl $0xffffffff, %r12d      # imm = 0xFFFFFFFF
cmovll %ecx, %r12d
decq %rax
testl %eax, %eax
js 0x98ad
movl %eax, %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
movq (%r14), %rdx
cmpb $0x20, (%rdx,%rcx)
je 0x9892
movl %eax, %r12d
testl %r12d, %r12d
js 0x98d0
incl %r12d
xorl %r13d, %r13d
movq (%r14), %rax
movsbl (%rax,%r13), %esi
movq %rbx, %rdi
callq 0x3210
incq %r13
cmpq %r13, %r12
jne 0x98b8
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r15, %rdi
je 0x98f2
callq 0x3260
movq %r14, %rdi
callq 0x3390
// File: /workspace/github_cpp_makefile_star2_O1/AsherGlick[P]CommentHeader/source/main.cpp
// Function: thisyear[abi:cxx11]()
string thisyear() {
  #define SECONDSPERYEAR 31556926
  #define EPOCH 1970
  unsigned long year = (time(NULL)/SECONDSPERYEAR)+EPOCH;
  stringstream ss;
  ss << year;
  return ss.str();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x190, %rsp            # imm = 0x190
movq %rdi, %rbx
xorl %edi, %edi
callq 0x3240
movabsq $0x22068a920e22bed1, %rcx # imm = 0x22068A920E22BED1
imulq %rcx
movq %rdx, %rax
shrq $0x3f, %rax
sarq $0x16, %rdx
leaq (%rdx,%rax), %r14
addq $0x7b2, %r14            # imm = 0x7B2
leaq -0x198(%rbp), %rdi
callq 0x31c0
leaq -0x188(%rbp), %rdi
movq %r14, %rsi
callq 0x3190
leaq -0x180(%rbp), %rsi
movq %rbx, %rdi
callq 0x3370
movq 0x6ebc(%rip), %rsi      # 0x13fa0
leaq -0x198(%rbp), %rdi
callq 0x31e0
leaq -0x118(%rbp), %rdi
callq 0x30e0
movq %rbx, %rax
addq $0x190, %rsp            # imm = 0x190
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
movq 0x6e8b(%rip), %rsi      # 0x13fa0
leaq -0x198(%rbp), %rdi
callq 0x31e0
leaq -0x118(%rbp), %rdi
callq 0x30e0
movq %rbx, %rdi
callq 0x3390
nop
// File: /workspace/github_cpp_makefile_star2_O1/AndrewAlbert[P]Compiler-Theory/SourceCode/scanner.cpp
// Function: Scanner::getToken()
token_type Scanner::getToken(){
	return_token.type = ScanOneToken(fPtr, &return_token);
	return_token.line = line_number;	
	if(debug && return_token.type != T_EOF){
		cout << return_token.ascii << " ";
	}
	return return_token;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x130(%rsi), %rsi
leaq 0x8(%r14), %rdx
movq %r14, %rdi
callq 0x328e
movl %eax, 0x28(%r14)
movl (%r14), %ecx
movl %ecx, 0x2c(%r14)
cmpl $0x15d, %eax            # imm = 0x15D
je 0x3251
cmpb $0x0, 0x138(%r14)
je 0x3251
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
movq 0x1eda0(%rip), %rdi     # 0x21fd8
callq 0x2230
leaq 0x16078(%rip), %rsi     # 0x192bc
movl $0x1, %edx
movq %rax, %rdi
callq 0x2230
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
addq %rsi, %rdx
movq %rbx, %rdi
callq 0x3ba4
movq %rbx, %rdi
addq $0x20, %rdi
addq $0x28, %r14
movl $0x108, %edx            # imm = 0x108
movq %r14, %rsi
callq 0x2190
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/AndrewAlbert[P]Compiler-Theory/SourceCode/parser.cpp
// Function: Parser::Program()
void Parser::Program(){
	Scopes->newScope(); //Create new scope for the program
	declareRunTime(); //set up runtime functions as global in the outermost scope
	if( !ProgramHeader() ) ReportError("Expected program header");
	if( !ProgramBody() ) ReportError("Expected program body");
	if( !CheckToken(T_PERIOD) ) ReportWarning("expected '.' at end of program");
	if( CheckToken(T_EOF) ) Scopes->exitScope(); //exit program scope once program ends
		
	else ReportError("Found some tokens remaining in file when end of program was expected");
	return;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
movq 0x90(%rdi), %rdi
callq 0xfafe
movq %rbx, %rdi
callq 0x5e6a
movq %rbx, %rdi
callq 0x63a8
testb %al, %al
jne 0x4276
leaq 0x50(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x15115(%rip), %rsi     # 0x19355
leaq 0x15125(%rip), %rdx     # 0x1936c
leaq 0x40(%rsp), %r14
movq %r14, %rdi
callq 0x3c34
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5696
movq 0x40(%rsp), %rdi
cmpq %r15, %rdi
je 0x4276
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
callq 0x6560
movq %rbx, %rdi
movl $0x12b, %esi            # imm = 0x12B
callq 0x5c0a
testb %al, %al
jne 0x42d5
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x150ce(%rip), %rsi     # 0x1936d
leaq 0x150e5(%rip), %rdx     # 0x1938b
leaq 0x20(%rsp), %r14
movq %r14, %rdi
callq 0x3c34
movq %rbx, %rdi
movq %r14, %rsi
callq 0x4374
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0x42d5
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
movl $0x15d, %esi            # imm = 0x15D
callq 0x5c0a
testb %al, %al
je 0x42f4
movq 0x90(%rbx), %rdi
callq 0xfb86
jmp 0x4337
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x15088(%rip), %rsi     # 0x1938c
leaq 0x150c5(%rip), %rdx     # 0x193d0
movq %rsp, %r14
movq %r14, %rdi
callq 0x3c34
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5696
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0x4337
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2200
addq $0x60, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
jmp 0x435c
movq %rax, %rbx
movq 0x20(%rsp), %rdi
jmp 0x435c
movq %rax, %rbx
movq 0x40(%rsp), %rdi
cmpq %r15, %rdi
je 0x436c
movq (%r15), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O1/AndrewAlbert[P]Compiler-Theory/SourceCode/parser.cpp
// Function: Parser::~Parser()
Parser::~Parser(){
	// set all pointers to nullptr
	token = nullptr;
	scanner = nullptr;
	Scopes = nullptr;
	generator = nullptr;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x90(%rdi)
movups %xmm0, 0x80(%rdi)
movq 0x58(%rdi), %rdi
leaq 0x68(%rbx), %rax
cmpq %rax, %rdi
je 0x49e5
movq (%rax), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
popq %rbx
jmp 0xded4
// File: /workspace/github_cpp_makefile_star2_O1/AndrewAlbert[P]Compiler-Theory/SourceCode/parser.cpp
// Function: Parser::ProgramHeader()
bool Parser::ProgramHeader(){
	if(CheckToken(T_PROGRAM)){
		string id;
		if( Identifier(id) ){
			Scopes->ChangeScopeName("Program " + id);	
			if(CheckToken(T_IS)) return true;
			else{
				ReportError("expected 'is' after program identifier");
				return false;
			}
		}
		else{
			ReportError("expected program identifier after 'program'");
			return false;
		}
	}
	else return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
movl $0x101, %esi            # imm = 0x101
callq 0x5c0a
testb %al, %al
je 0x6482
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x6a86
testb %al, %al
je 0x6486
movq 0x90(%rbx), %r14
leaq 0x12fcf(%rip), %rsi     # 0x193d1
leaq 0x68(%rsp), %rdi
leaq 0x8(%rsp), %rdx
callq 0xddc7
leaq 0x68(%rsp), %rsi
movq %r14, %rdi
callq 0x1029e
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6439
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
movl $0x102, %esi            # imm = 0x102
callq 0x5c0a
movb $0x1, %bpl
testb %al, %al
jne 0x64cb
leaq 0x58(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x12f7d(%rip), %rsi     # 0x193da
leaq 0x12f9c(%rip), %rdx     # 0x19400
leaq 0x48(%rsp), %rdi
callq 0x3c34
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0x5696
movq 0x48(%rsp), %rdi
jmp 0x64b9
xorl %ebp, %ebp
jmp 0x64e2
leaq 0x38(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x12f6b(%rip), %rsi     # 0x19401
leaq 0x12f8f(%rip), %rdx     # 0x1942c
leaq 0x28(%rsp), %rdi
callq 0x3c34
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
callq 0x5696
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x64c9
movq (%r14), %rsi
incq %rsi
callq 0x2200
xorl %ebp, %ebp
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x64e2
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
movl %ebp, %eax
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r14, %rdi
je 0x6541
movq 0x58(%rsp), %rsi
jmp 0x6532
jmp 0x653e
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x6541
movq 0x38(%rsp), %rsi
jmp 0x6532
movq %rax, %rbx
leaq 0x78(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x6541
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x2200
jmp 0x6541
jmp 0x653e
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x6558
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O1/AndrewAlbert[P]Compiler-Theory/SourceCode/parser.cpp
// Function: Parser::Identifier(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&)
bool Parser::Identifier(string &id){
	string tmp = token->ascii;
	bool ret_val = CheckToken(TYPE_IDENTIFIER);
	if(ret_val){
		id = tmp;
		return true;
	}
	else return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x80(%rdi), %rax
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x3ba4
movq %r14, %rdi
movl $0x11c, %esi            # imm = 0x11C
callq 0x5c0a
movl %eax, %ebp
testb %al, %al
je 0x6ada
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x2120
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x6af1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x6b18
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O1/AndrewAlbert[P]Compiler-Theory/SourceCode/parser.cpp
// Function: Parser::Statement()
bool Parser::Statement(){
	string id = "";
	if( IfStatement() ) return true;
	else if( LoopStatement() ) return true;
	else if( ReturnStatement() ) return true;
	else if( Assignment(id) ) return true;
	else if( ProcedureCall(id) ) return true;
	else return false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %r14
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x13a43(%rip), %rdx     # 0x1a95d
leaq 0x8(%rsp), %rdi
movq %rdx, %rsi
callq 0x3c34
movq %r14, %rdi
callq 0x8a44
movb $0x1, %bl
testb %al, %al
jne 0x6fa5
movq %r14, %rdi
callq 0x99e8
testb %al, %al
jne 0x6fa5
movq %r14, %rdi
callq 0xa558
testb %al, %al
jne 0x6fa5
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0xa586
testb %al, %al
jne 0x6fa5
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0x3ba4
leaq 0x28(%rsp), %rsi
movq %r14, %rdi
callq 0x7dec
movl %eax, %ebx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x6fa5
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2200
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x6fbc
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
movl %ebx, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x6fe9
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2200
jmp 0x6fe9
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x7000
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O1/AndrewAlbert[P]Compiler-Theory/SourceCode/parser.cpp
// Function: Parser::ProcedureDeclaration(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, scopeValue&, bool)
bool Parser::ProcedureDeclaration(string &id, scopeValue &procDeclaration, bool global){
	//Get Procedure Header
	if( ProcedureHeader(id, procDeclaration, global) ){
		if( ProcedureBody() ) return true;
		else{
			ReportFatalError("Expected procedure body after procedure header.");
			return true;
		}
	}
	else return false;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
callq 0x72b2
movl %eax, %ebp
testb %al, %al
je 0x702c
movq %rbx, %rdi
callq 0x76d6
testb %al, %al
je 0x7039
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x126cb(%rip), %rsi     # 0x19714
leaq 0x126f3(%rip), %rdx     # 0x19743
leaq 0x8(%rsp), %r14
movq %r14, %rdi
callq 0x3c34
movq %rbx, %rdi
movq %r14, %rsi
callq 0x49ee
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x7082
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O1/AndrewAlbert[P]Compiler-Theory/SourceCode/parser.cpp
// Function: Parser::VariableDeclaration(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>&, scopeValue&)
bool Parser::VariableDeclaration(string &id, scopeValue &varEntry){
	//get variable type, otherwise no variable should be declared
	if( !TypeMark(varEntry.type) ) return false;
	else{
		//get variable identifier
		if( Identifier(id) ){
			// Get size for array variable declarations
			if(CheckToken(T_LBRACKET)){
				if(CheckToken(TYPE_INTEGER)){
					varEntry.size = token->val.intValue;
					if( !CheckToken(T_RBRACKET) ) ReportError("expected ']' at end of array variable declaration.");
					return true;
				}
				else{
					ReportLineError("Expected integer for array size in variable declaration.");
					return true;
				}
			}
			else{
				varEntry.size = 0;
				return true;
			}
		}
		else{
			ReportLineError("Bad line. Expected variable identifier for declaration after type mark.");
			return true;
		}
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %r14
movq %rdx, %rsi
callq 0x7230
movl %eax, %ebx
testb %al, %al
je 0x71a7
movq %r14, %rdi
movq %r12, %rsi
callq 0x6a86
testb %al, %al
je 0x7151
movq %r14, %rdi
movl $0x135, %esi            # imm = 0x135
callq 0x5c0a
testb %al, %al
je 0x719f
movq %r14, %rdi
movl $0x10a, %esi            # imm = 0x10A
callq 0x5c0a
testb %al, %al
je 0x71b5
movq 0x80(%r14), %rax
movl 0x28(%rax), %eax
movl %eax, 0x4(%r15)
movq %r14, %rdi
movl $0x136, %esi            # imm = 0x136
callq 0x5c0a
testb %al, %al
jne 0x71a7
leaq 0x58(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x1253f(%rip), %rsi     # 0x19660
leaq 0x1256a(%rip), %rdx     # 0x19692
leaq 0x48(%rsp), %r15
movq %r15, %rdi
callq 0x3c34
movq %r14, %rdi
movq %r15, %rsi
callq 0x5696
movq 0x48(%rsp), %rdi
cmpq %r12, %rdi
je 0x71a7
movq 0x58(%rsp), %rsi
jmp 0x7195
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x1256a(%rip), %rsi     # 0x196cc
leaq 0x125aa(%rip), %rdx     # 0x19713
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x3c34
movq %r14, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0x4e82
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x71a7
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
jmp 0x71a7
movl $0x0, 0x4(%r15)
movl %ebx, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x124cd(%rip), %rsi     # 0x19693
leaq 0x124fe(%rip), %rdx     # 0x196cb
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq 0x3c34
movq %r14, %rdi
movq %r15, %rsi
movl $0x1, %edx
callq 0x4e82
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0x71a7
movq 0x38(%rsp), %rsi
jmp 0x7195
movq %rax, %rbx
movq 0x48(%rsp), %rdi
jmp 0x7217
movq %rax, %rbx
movq 0x28(%rsp), %rdi
jmp 0x7217
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x7228
movq (%r12), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O1/AndrewAlbert[P]Compiler-Theory/SourceCode/parser.cpp
// Function: Parser::TypeMark(int&)
bool Parser::TypeMark(int &type){
	if( CheckToken(T_INTEGER) ) type = TYPE_INTEGER;
	else if( CheckToken(T_FLOAT) ) type = TYPE_FLOAT;
	else if( CheckToken(T_BOOL) ) type = TYPE_BOOL;
	else if( CheckToken(T_STRING) ) type = TYPE_STRING;
	else if( CheckToken(T_CHAR) ) type = TYPE_CHAR;
	else return false;
	return true;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl $0x10a, %ebp            # imm = 0x10A
movl $0x10a, %esi            # imm = 0x10A
callq 0x5c0a
testb %al, %al
jne 0x72a5
movl $0x10b, %ebp            # imm = 0x10B
movq %r14, %rdi
movl $0x10b, %esi            # imm = 0x10B
callq 0x5c0a
testb %al, %al
jne 0x72a5
movl $0x10c, %ebp            # imm = 0x10C
movq %r14, %rdi
movl $0x10c, %esi            # imm = 0x10C
callq 0x5c0a
testb %al, %al
jne 0x72a5
movl $0x10d, %ebp            # imm = 0x10D
movq %r14, %rdi
movl $0x10d, %esi            # imm = 0x10D
callq 0x5c0a
testb %al, %al
jne 0x72a5
movl $0x10e, %ebp            # imm = 0x10E
movq %r14, %rdi
movl $0x10e, %esi            # imm = 0x10E
callq 0x5c0a
testb %al, %al
je 0x72ae
movl %ebp, (%rbx)
movb $0x1, %al
popq %rbx
popq %r14
popq %rbp
retq
xorl %eax, %eax
jmp 0x72a9
// File: /workspace/github_cpp_makefile_star2_O1/AndrewAlbert[P]Compiler-Theory/SourceCode/parser.cpp
// Function: Parser::ParameterList(scopeValue&)
bool Parser::ParameterList(scopeValue &procEntry){
	if(Parameter(procEntry)){
		while(CheckToken(T_COMMA)){
			if( !Parameter(procEntry) ) ReportError("Expected parameter after ',' in procedure's parameter list");
		}
	}
	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %rbx
movq %rdi, %r14
callq 0x8774
testb %al, %al
je 0x7db9
movq %r14, %rdi
movl $0x134, %esi            # imm = 0x134
callq 0x5c0a
testb %al, %al
je 0x7db9
leaq 0x18(%rsp), %rbp
leaq 0x11d11(%rip), %r15     # 0x19a69
leaq 0x11d44(%rip), %r12     # 0x19aa3
leaq 0x8(%rsp), %r13
movq %r14, %rdi
movq %rbx, %rsi
callq 0x8774
testb %al, %al
jne 0x7da8
movq %rbp, 0x8(%rsp)
movq %r13, %rdi
movq %r15, %rsi
movq %r12, %rdx
callq 0x3c34
movq %r14, %rdi
movq %r13, %rsi
callq 0x5696
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x7da8
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
movq %r14, %rdi
movl $0x134, %esi            # imm = 0x134
callq 0x5c0a
testb %al, %al
jne 0x7d64
movb $0x1, %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %rbp, %rdi
je 0x7de4
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O1/AndrewAlbert[P]Compiler-Theory/SourceCode/parser.cpp
// Function: Parser::Expression(int&, int&)
bool Parser::Expression(int &type, int &size){
	//flag used to determine if an expression is required following a 'NOT' token
	bool notOperation;
	if( CheckToken(T_NOT) ) notOperation = true;
	else notOperation = false;
	
	//get type and size of first arithOp
	if( ArithOp(type, size) ){
		if( (notOperation) && (type != TYPE_BOOL) && (type != TYPE_INTEGER) )ReportError("'NOT' operator is defined only for type Bool and Integer.");
		else if (notOperation) generator->NotOnRegister(type, size);
		ExpressionPrime(type, size, true, true);
		return true;
	}
	else if (notOperation){
		ReportFatalError("Expected an integer / boolean ArithOp following 'NOT'");
		return true;
	}
	else{
		return false;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
movl $0x10f, %esi            # imm = 0x10F
callq 0x5c0a
movl %eax, %r12d
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0xac14
movl %eax, %ebp
testb %al, %al
je 0x86a0
testb %r12b, %r12b
je 0x871e
movl (%r15), %esi
cmpl $0x10a, %esi            # imm = 0x10A
je 0x8686
cmpl $0x10c, %esi            # imm = 0x10C
jne 0x86d8
testb %r12b, %r12b
je 0x871e
movq 0x98(%rbx), %rdi
movl (%r14), %edx
callq 0x13140
jmp 0x871e
testb %r12b, %r12b
je 0x8737
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x11b9c(%rip), %rsi     # 0x1a255
leaq 0x11bca(%rip), %rdx     # 0x1a28a
leaq 0x28(%rsp), %r14
movq %r14, %rdi
callq 0x3c34
movq %rbx, %rdi
movq %r14, %rsi
callq 0x49ee
leaq 0x18(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x11b33(%rip), %rsi     # 0x1a21b
leaq 0x11b65(%rip), %rdx     # 0x1a254
leaq 0x8(%rsp), %r12
movq %r12, %rdi
callq 0x3c34
movq %rbx, %rdi
movq %r12, %rsi
callq 0x5696
movq 0x8(%rsp), %rdi
cmpq %r13, %rdi
je 0x871e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl $0x1, %ecx
movl $0x1, %r8d
callq 0xac56
movl %ebp, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x8(%rsp), %rdi
jmp 0x875a
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0x876b
movq (%r13), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
callq 0x2330
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %r14
movq 0x80(%rdi), %rax
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x3ba4
movq %r14, %rdi
movl $0x10a, %esi            # imm = 0x10A
callq 0x5c0a
movl %eax, %ebx
testb %al, %al
je 0xd08a
movq 0x98(%r14), %r14
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0x3ba4
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rdx
movq %r14, %rsi
movl $0x10a, %ecx            # imm = 0x10A
callq 0x13428
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xd073
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x2200
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0xd08a
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2200
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xd0a1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
movl %ebx, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0xd0ce
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2200
jmp 0xd0ce
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xd0e5
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
callq 0x2330
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %r14
movq 0x80(%rdi), %rax
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x3ba4
movq %r14, %rdi
movl $0x10b, %esi            # imm = 0x10B
callq 0x5c0a
movl %eax, %ebx
testb %al, %al
je 0xd1a4
movq 0x98(%r14), %r14
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0x3ba4
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rdx
movq %r14, %rsi
movl $0x10b, %ecx            # imm = 0x10B
callq 0x13428
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xd18d
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x2200
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0xd1a4
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2200
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xd1bb
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
movl %ebx, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0xd1e8
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2200
jmp 0xd1e8
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xd1ff
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
callq 0x2330
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %r14
movq 0x80(%rdi), %rax
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x3ba4
movq %r14, %rdi
movl $0x10d, %esi            # imm = 0x10D
callq 0x5c0a
movl %eax, %ebx
testb %al, %al
je 0xda26
movq 0x98(%r14), %r14
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0x3ba4
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rdx
movq %r14, %rsi
movl $0x10d, %ecx            # imm = 0x10D
callq 0x13428
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xda0f
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x2200
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0xda26
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2200
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xda3d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
movl %ebx, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0xda6a
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2200
jmp 0xda6a
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xda81
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
callq 0x2330
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %r14
movq 0x80(%rdi), %rax
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x3ba4
movq %r14, %rdi
movl $0x10e, %esi            # imm = 0x10E
callq 0x5c0a
movl %eax, %ebx
testb %al, %al
je 0xdb40
movq 0x98(%r14), %r14
leaq 0x38(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0x3ba4
leaq 0x48(%rsp), %rdi
leaq 0x28(%rsp), %rdx
movq %r14, %rsi
movl $0x10e, %ecx            # imm = 0x10E
callq 0x13428
leaq 0x58(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xdb29
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x2200
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0xdb40
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2200
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xdb57
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
movl %ebx, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r12, %rdi
je 0xdb84
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2200
jmp 0xdb84
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0xdb9b
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
callq 0x2330
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0xa0, %rsp
movq %rdi, %rbx
movq 0x80(%rdi), %rax
leaq 0x50(%rsp), %r14
movq %r14, -0x10(%r14)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq 0x40(%rsp), %rdi
callq 0x3ba4
movq %rbx, %rdi
movl $0x115, %esi            # imm = 0x115
callq 0x5c0a
testb %al, %al
je 0xdc52
movq 0x98(%rbx), %rbx
leaq 0x30(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xcb10(%rip), %rsi      # 0x1a70f
leaq 0xcb0a(%rip), %rdx      # 0x1a710
leaq 0x20(%rsp), %rdi
callq 0x3c34
leaq 0x80(%rsp), %rdi
leaq 0x20(%rsp), %rdx
movq %rbx, %rsi
movl $0x10c, %ecx            # imm = 0x10C
callq 0x13428
leaq 0x90(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xdc4b
movq 0x90(%rsp), %rsi
incq %rsi
callq 0x2200
movq 0x20(%rsp), %rdi
jmp 0xdcbd
movq %rbx, %rdi
movl $0x116, %esi            # imm = 0x116
callq 0x5c0a
testb %al, %al
je 0xdcd1
movq 0x98(%rbx), %rbx
leaq 0x10(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0xca97(%rip), %rsi      # 0x1a711
leaq 0xca91(%rip), %rdx      # 0x1a712
movq %rsp, %rdi
callq 0x3c34
leaq 0x60(%rsp), %rdi
movq %rsp, %rdx
movq %rbx, %rsi
movl $0x10c, %ecx            # imm = 0x10C
callq 0x13428
leaq 0x70(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xdcb9
movq 0x70(%rsp), %rsi
incq %rsi
callq 0x2200
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xdccd
movq (%r15), %rsi
incq %rsi
callq 0x2200
movb $0x1, %bl
jmp 0xdcd3
xorl %ebx, %ebx
movq 0x40(%rsp), %rdi
cmpq %r14, %rdi
je 0xdcea
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x2200
movl %ebx, %eax
addq $0xa0, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r15, %rdi
je 0xdd2f
movq 0x10(%rsp), %rsi
jmp 0xdd20
jmp 0xdd2c
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r15, %rdi
je 0xdd2f
movq 0x30(%rsp), %rsi
incq %rsi
callq 0x2200
jmp 0xdd2f
jmp 0xdd2c
movq %rax, %rbx
movq 0x40(%rsp), %rdi
cmpq %r14, %rdi
je 0xdd46
movq 0x50(%rsp), %rsi
incq %rsi
callq 0x2200
movq %rbx, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O1/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
movl %esi, %ebp
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
xorl %ecx, %ecx
movl %ecx, 0x8(%rdi)
movq %rcx, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
leaq 0x38(%rdi), %rax
movl %ecx, 0x38(%rdi)
movq %rcx, 0x40(%rdi)
movq %rax, 0x48(%rdi)
movq %rax, 0x50(%rdi)
movq %rcx, 0x58(%rdi)
leaq 0x60(%rdi), %r15
leaq 0x70(%rdi), %r12
movq %r12, 0x60(%rdi)
movq %rcx, 0x68(%rdi)
movb $0x0, 0x70(%rdi)
leaq 0xbe89(%rip), %rcx      # 0x1a95d
movq %r15, %rdi
xorl %esi, %esi
xorl %edx, %edx
xorl %r8d, %r8d
callq 0x22e0
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, %r14
movq (%r15), %rdi
cmpq %r12, %rdi
je 0xeb13
movq (%r12), %rsi
incq %rsi
callq 0x2200
leaq 0x30(%rbx), %rdi
callq 0xf49e
movq %rbx, %rdi
callq 0xf49e
movq %r14, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O1/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 0xf53a
leaq 0x38(%r12), %rcx
cmpq %rcx, %rax
je 0xeb98
xorl %eax, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x11e, (%rbx)          # imm = 0x11E
je 0xebc3
movl 0x80(%r12), %eax
movl %eax, 0x44(%rbx)
movl 0x4(%rbx), %ecx
cmpl $0x2, %ecx
movl $0x1, %edx
cmovgel %ecx, %edx
addl %eax, %edx
movl %edx, 0x80(%r12)
testb %bpl, %bpl
je 0xebde
movq %r12, %rdi
movq %r14, %rsi
callq 0xf20e
movq %rax, %rdi
movq %rbx, %rsi
callq 0xf28a
movq %r15, %rdi
movq %r14, %rsi
callq 0xf20e
movq %rax, %rdi
movq %rbx, %rsi
callq 0xf28a
// File: /workspace/github_cpp_makefile_star2_O1/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 0xf53a
cmpq %rbx, %rax
setne %al
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %r15
pushq %r14
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x30(%rsi), %rdi
movq %rdx, %rsi
callq 0xf53a
addq $0x38, %r15
cmpq %r15, %rax
je 0xec82
movq %rax, %r14
movq 0x40(%rax), %rax
movq %rax, (%rbx)
leaq 0x8(%rbx), %r15
movq %r14, %rsi
addq $0x48, %rsi
movq %r15, %rdi
callq 0xe0e0
leaq 0x20(%rbx), %rdi
leaq 0x30(%rbx), %rax
movq %rax, 0x20(%rbx)
movq 0x60(%r14), %rsi
movq 0x68(%r14), %rdx
addq %rsi, %rdx
callq 0x3ba4
movq 0x80(%r14), %rax
movq %rax, 0x40(%rbx)
jmp 0xecc0
leaq 0x8(%rbx), %rdi
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rbx)
xorl %eax, %eax
movq %rax, 0x18(%rbx)
leaq 0x30(%rbx), %rcx
movq %rcx, 0x20(%rbx)
movq %rax, 0x28(%rbx)
movb $0x0, 0x30(%rbx)
movl $0x15e, (%rbx)          # imm = 0x15E
movq %rsp, %rsi
movq %rax, 0x10(%rsi)
movaps %xmm0, (%rsi)
callq 0xf2c8
movq %rsp, %rdi
callq 0xdea4
movq %rbx, %rax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r14
movq %rsp, %rdi
callq 0xdea4
movq %rbx, %rdi
callq 0xde7a
jmp 0xeced
movq %rax, %r14
movq %r15, %rdi
callq 0xdea4
movq %r14, %rdi
callq 0x2330
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xfb38
movq %rax, 0x8(%r14)
movl $0x90, %edi
callq 0x21f0
movq %rax, %rbx
movq %rax, %rdi
xorl %esi, %esi
callq 0xea7c
movq %rbx, (%r14)
movq 0x8(%r14), %rax
movq %rax, 0x88(%rbx)
jmp 0xfb64
movl $0x90, %edi
callq 0x21f0
movq %rax, %rbx
movq %rax, %rdi
movl $0x1, %esi
callq 0xea7c
movq %rbx, (%r14)
movq 0x8(%r14), %rax
movq %rax, 0x88(%rbx)
movq %rbx, 0x10(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
jmp 0xfb6e
movq %rax, %r14
movl $0x90, %esi
movq %rbx, %rdi
callq 0x2200
movq %r14, %rdi
callq 0x2330
// File: /workspace/github_cpp_makefile_star2_O1/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
movq (%rdi), %rdi
movb 0x18(%rbx), %al
testq %rdi, %rdi
je 0xfbd3
testb %al, %al
je 0xfba1
callq 0xecf6
movq (%rbx), %r14
movq %r14, 0x8(%rbx)
movq 0x88(%r14), %rax
movq %rax, (%rbx)
testq %r14, %r14
je 0xfc20
movq %r14, %rdi
callq 0xeb2c
movl $0x90, %esi
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2200
testb %al, %al
je 0xfc20
movq 0x123fa(%rip), %rbx     # 0x21fd8
leaq 0xad99(%rip), %rsi      # 0x1a97e
movl $0xf, %edx
movq %rbx, %rdi
callq 0x2230
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2140
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x98, %rsp
movq (%rdi), %r13
testq %r13, %r13
je 0xfc99
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl %ecx, 0xc(%rsp)
leaq 0x40(%rsp), %rbx
movq %rbx, -0x10(%rbx)
movq (%rsi), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq 0x30(%rsp), %rbp
movq %rbp, %rdi
callq 0x3ba4
movq %r13, %rdi
movq %rbp, %rsi
xorl %edx, %edx
callq 0xebf4
movl %eax, %ebp
movq 0x30(%rsp), %rdi
cmpq %rbx, %rdi
je 0xfc94
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x2200
testb %bpl, %bpl
je 0xfca0
xorl %ebx, %ebx
jmp 0xfd54
movq (%r12), %r12
leaq 0x20(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq 0x10(%rsp), %rdi
callq 0x3ba4
movq (%r14), %rax
leaq 0x58(%rsp), %r15
movq %rax, -0x8(%r15)
leaq 0x8(%r14), %rsi
movq %r15, %rdi
callq 0xe0e0
leaq 0x70(%rsp), %rdi
leaq 0x80(%rsp), %r13
movq %r13, -0x10(%r13)
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
addq %rsi, %rdx
callq 0x3ba4
movq 0x40(%r14), %rax
leaq 0x50(%rsp), %rcx
movq %rax, 0x40(%rcx)
movzbl 0xc(%rsp), %edx
leaq 0x10(%rsp), %rsi
movq %r12, %rdi
callq 0xeb64
movq 0x70(%rsp), %rdi
cmpq %r13, %rdi
je 0xfd33
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x2200
movq %r15, %rdi
callq 0xdea4
movq 0x10(%rsp), %rdi
movb $0x1, %bl
cmpq %rbp, %rdi
je 0xfd54
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x2200
movl %ebx, %eax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x50(%rsp), %rdi
callq 0xde7a
jmp 0xfd87
movq %rax, %r14
movq %r15, %rdi
callq 0xdea4
jmp 0xfd87
movq %rax, %r14
movq 0x10(%rsp), %rdi
cmpq %rbp, %rdi
je 0xfd9d
movq (%rbp), %rsi
incq %rsi
callq 0x2200
movq %r14, %rdi
callq 0x2330
movq %rax, %r14
movq 0x30(%rsp), %rdi
movq %rbx, %rbp
cmpq %rbx, %rdi
jne 0xfd91
jmp 0xfd9d
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x98, %rsp
movq (%rdi), %rax
movq 0x88(%rax), %r14
testq %r14, %r14
je 0xfe2e
movq %rdx, %r15
movq %rsi, %r12
movl %ecx, 0xc(%rsp)
leaq 0x40(%rsp), %rbx
movq %rbx, -0x10(%rbx)
movq (%rsi), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
leaq 0x30(%rsp), %r13
movq %r13, %rdi
callq 0x3ba4
movq %r14, %rdi
movq %r13, %rsi
xorl %edx, %edx
callq 0xebf4
movl %eax, %ebp
movq 0x30(%rsp), %rdi
cmpq %rbx, %rdi
je 0xfe29
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x2200
testb %bpl, %bpl
je 0xfe35
xorl %ebx, %ebx
jmp 0xfee8
leaq 0x20(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq (%r12), %rsi
movq 0x8(%r12), %rdx
addq %rsi, %rdx
leaq 0x10(%rsp), %rdi
callq 0x3ba4
movq (%r15), %rax
leaq 0x58(%rsp), %r12
movq %rax, -0x8(%r12)
leaq 0x8(%r15), %rsi
movq %r12, %rdi
callq 0xe0e0
leaq 0x70(%rsp), %rdi
leaq 0x80(%rsp), %r13
movq %r13, -0x10(%r13)
movq 0x20(%r15), %rsi
movq 0x28(%r15), %rdx
addq %rsi, %rdx
callq 0x3ba4
movq 0x40(%r15), %rax
leaq 0x50(%rsp), %rcx
movq %rax, 0x40(%rcx)
movzbl 0xc(%rsp), %edx
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0xeb64
movq 0x70(%rsp), %rdi
cmpq %r13, %rdi
je 0xfec7
movq 0x80(%rsp), %rsi
incq %rsi
callq 0x2200
movq %r12, %rdi
callq 0xdea4
movq 0x10(%rsp), %rdi
movb $0x1, %bl
cmpq %rbp, %rdi
je 0xfee8
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x2200
movl %ebx, %eax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq 0x50(%rsp), %rdi
callq 0xde7a
jmp 0xff1b
movq %rax, %r14
movq %r12, %rdi
callq 0xdea4
jmp 0xff1b
movq %rax, %r14
movq 0x10(%rsp), %rdi
cmpq %rbp, %rdi
je 0xff31
movq (%rbp), %rsi
incq %rsi
callq 0x2200
movq %r14, %rdi
callq 0x2330
movq %rax, %r14
movq 0x30(%rsp), %rdi
movq %rbx, %rbp
cmpq %rbx, %rdi
jne 0xff25
jmp 0xff31
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
movq 0x308(%rdi), %r14
testq %r14, %r14
je 0x108a0
movq %r14, %rdi
callq 0x2370
testl %eax, %eax
je 0x1085f
testq %r14, %r14
je 0x108a0
movq %r14, %rdi
jmp 0x1089b
movq %rbx, %rdi
callq 0x10a40
movq %rbx, %rdi
callq 0x10a9a
movq 0x308(%rbx), %rcx
leaq 0xa169(%rip), %rdi      # 0x1a9e6
movl $0xe, %esi
movl $0x1, %edx
callq 0x2390
movq %rbx, %rdi
callq 0x10bd0
movq 0x308(%rbx), %rdi
callq 0x21e0
cmpb $0x0, 0x330(%rbx)
jne 0x108cb
leaq 0x310(%rbx), %r14
leaq 0xa0a6(%rip), %rsi      # 0x1a95d
movq %r14, %rdi
callq 0x20a0
testl %eax, %eax
je 0x108cb
movq (%r14), %rdi
callq 0x2350
movq 0x310(%rbx), %rdi
leaq 0x320(%rbx), %rax
cmpq %rax, %rdi
je 0x108e9
movq (%rax), %rsi
incq %rsi
callq 0x2200
leaq 0x2b8(%rbx), %rdi
callq 0x17120
leaq 0x250(%rbx), %rdi
callq 0x17170
movq 0x230(%rbx), %rdi
leaq 0x240(%rbx), %rax
cmpq %rax, %rdi
je 0x1091f
movq (%rax), %rsi
incq %rsi
callq 0x2200
leaq 0x1d0(%rbx), %rdi
callq 0xded4
leaq 0x180(%rbx), %rdi
callq 0xded4
leaq 0x130(%rbx), %rdi
callq 0xded4
leaq 0xf0(%rbx), %rdi
callq 0x1730e
movq 0xc8(%rbx), %rdi
leaq 0xd8(%rbx), %rax
cmpq %rax, %rdi
je 0x1096d
movq (%rax), %rsi
incq %rsi
callq 0x2200
movq 0xa8(%rbx), %rdi
leaq 0xb8(%rbx), %rax
cmpq %rax, %rdi
je 0x1098b
movq (%rax), %rsi
incq %rsi
callq 0x2200
movq 0x88(%rbx), %rdi
leaq 0x98(%rbx), %rax
cmpq %rax, %rdi
je 0x109a9
movq (%rax), %rsi
incq %rsi
callq 0x2200
movq 0x68(%rbx), %rdi
leaq 0x78(%rbx), %rax
cmpq %rax, %rdi
je 0x109c1
movq (%rax), %rsi
incq %rsi
callq 0x2200
movq 0x48(%rbx), %rdi
leaq 0x58(%rbx), %rax
cmpq %rax, %rdi
je 0x109d9
movq (%rax), %rsi
incq %rsi
callq 0x2200
movq 0x28(%rbx), %rdi
leaq 0x38(%rbx), %rax
cmpq %rax, %rdi
je 0x109f1
movq (%rax), %rsi
incq %rsi
callq 0x2200
movq 0x8(%rbx), %rdi
addq $0x18, %rbx
cmpq %rbx, %rdi
je 0x10a10
movq (%rbx), %rsi
incq %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2200
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq %rax, %rdi
callq 0x3aa4
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbx
movq %rdi, %rbx
movq 0x308(%rdi), %rcx
leaq 0xa9b6(%rip), %rdi      # 0x1b408
movl $0x16, %esi
movl $0x1, %edx
callq 0x2390
movq 0x308(%rbx), %rcx
leaq 0xa9b0(%rip), %rdi      # 0x1b41f
movl $0xf, %esi
movl $0x1, %edx
callq 0x2390
movq 0x118(%rbx), %rdx
testq %rdx, %rdx
je 0x10a96
decl %edx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x16d0e
movb $0x1, %al
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0x308(%rdi), %rcx
leaq 0xa3d7(%rip), %rdi      # 0x1ae8d
movl $0xd, %esi
movl $0x1, %edx
callq 0x2390
leaq 0x250(%rbx), %r14
leaq 0x230(%rbx), %r15
movabsq $0x3333333333333333, %rbp # imm = 0x3333333333333333
leaq 0xa3b7(%rip), %r12      # 0x1ae9b
leaq 0xa3d0(%rip), %r13      # 0x1aebb
movq 0x298(%rbx), %rax
movq %rax, %rcx
subq 0x278(%rbx), %rcx
sarq $0x3, %rcx
cmpq $0x1, %rax
adcq $-0x1, %rcx
leaq (%rcx,%rcx,2), %rax
movq 0x280(%rbx), %rcx
subq 0x288(%rbx), %rcx
sarq $0x3, %rcx
movabsq $-0x3333333333333333, %rdx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rdx, %rcx
leaq (%rcx,%rax,4), %rax
movq 0x260(%rbx), %rsi
movq 0x270(%rbx), %rcx
subq %rsi, %rcx
sarq $0x3, %rcx
imulq %rbp, %rcx
cmpq %rcx, %rax
je 0x10ba4
movl (%rsi), %eax
movl %eax, 0x228(%rbx)
addq $0x8, %rsi
movq %r15, %rdi
callq 0x2120
movq %r14, %rdi
callq 0x17b70
movq 0x308(%rbx), %rdi
movl 0x228(%rbx), %edx
movq 0x230(%rbx), %rcx
movq %r12, %rsi
xorl %eax, %eax
callq 0x22a0
movq 0x308(%rbx), %rdi
movl 0x228(%rbx), %edx
movq %r13, %rsi
xorl %eax, %eax
callq 0x22a0
jmp 0x10aeb
movq 0x308(%rbx), %rcx
leaq 0xa31a(%rip), %rdi      # 0x1aecc
movl $0x1f, %esi
movl $0x1, %edx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2390
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x9db5(%rip), %rsi      # 0x1a9f5
callq 0x2250
movq %rax, 0x308(%rbx)
testq %rax, %rax
je 0x10c61
movq %rax, %rdi
callq 0x2370
testl %eax, %eax
sete %bpl
jmp 0x10c63
xorl %ebp, %ebp
testb %bpl, %bpl
je 0x10c77
movq %rbx, %rdi
callq 0x10c98
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x9d79(%rip), %rdi      # 0x1a9f7
callq 0x21a0
movq 0x308(%rbx), %rdi
callq 0x21e0
movb $0x0, 0x330(%rbx)
jmp 0x10c70
// File: /workspace/github_cpp_makefile_star2_O1/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 %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq 0x308(%rdi), %rax
testl %edx, %edx
je 0x11154
movq %rdi, %rbx
movl $0xa, %edi
movq %rax, %rsi
callq 0x2280
movq 0x308(%rbx), %rdi
movq (%r14), %rdx
leaq 0x98ea(%rip), %rsi      # 0x1aa1f
xorl %eax, %eax
callq 0x22a0
movq 0x308(%rbx), %rsi
movl $0xa, %edi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x2280
movq (%r14), %rdx
leaq 0x98c1(%rip), %rsi      # 0x1aa1f
movq %rax, %rdi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x22a0
nop