LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: AndrewAlbert[P]Compiler-Theory/SourceCode/parser.cpp
// Function: Parser::ReportFatalError(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Parser::ReportFatalError(string message){
	generator->stopCodeGeneration();
	error_queue.push("Fatal Error: line - " + to_string(currentLine) + "\n\t" + message + "\n\tFound: " + textLine + " " + token->ascii);
	error = true;
	DisplayErrorQueue();
	exit(EXIT_FAILURE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movq %rsi, -0x140(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x130(%rbp)
movq %rax, %rcx
movq %rcx, -0x138(%rbp)
movq 0x98(%rax), %rdi
callq 0x19570
movq -0x130(%rbp), %rax
movl 0x78(%rax), %esi
leaq -0x110(%rbp), %rdi
movq %rdi, -0x128(%rbp)
callq 0x123d0
movq -0x128(%rbp), %rdx
leaq 0x1cbe1(%rip), %rsi     # 0x254e7
leaq -0xf0(%rbp), %rdi
callq 0x12380
jmp 0x8914
leaq 0x1e364(%rip), %rdx     # 0x26c7f
leaq -0xd0(%rbp), %rdi
leaq -0xf0(%rbp), %rsi
callq 0x12330
jmp 0x8930
movq -0x140(%rbp), %rdx
leaq -0xb0(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
callq 0x122e0
jmp 0x894c
leaq 0x1cba9(%rip), %rdx     # 0x254fc
leaq -0x90(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x12330
jmp 0x8968
movq -0x138(%rbp), %rdx
addq $0x58, %rdx
leaq -0x70(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x122e0
jmp 0x8985
leaq 0x1cb98(%rip), %rdx     # 0x25524
leaq -0x50(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x12330
jmp 0x899b
movq -0x138(%rbp), %rax
movq 0x80(%rax), %rdx
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x122e0
jmp 0x89b8
movq -0x130(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x122b0
jmp 0x89ca
leaq -0x30(%rbp), %rdi
callq 0x31a0
leaq -0x50(%rbp), %rdi
callq 0x31a0
leaq -0x70(%rbp), %rdi
callq 0x31a0
leaq -0x90(%rbp), %rdi
callq 0x31a0
leaq -0xb0(%rbp), %rdi
callq 0x31a0
leaq -0xd0(%rbp), %rdi
callq 0x31a0
leaq -0xf0(%rbp), %rdi
callq 0x31a0
leaq -0x110(%rbp), %rdi
callq 0x31a0
movq -0x138(%rbp), %rdi
movb $0x1, 0x51(%rdi)
callq 0x87a0
movl $0x1, %edi
callq 0x3330
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x118(%rbp)
movl %eax, -0x11c(%rbp)
jmp 0x8b2d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x118(%rbp)
movl %eax, -0x11c(%rbp)
jmp 0x8b21
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x118(%rbp)
movl %eax, -0x11c(%rbp)
jmp 0x8b15
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x118(%rbp)
movl %eax, -0x11c(%rbp)
jmp 0x8b09
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x118(%rbp)
movl %eax, -0x11c(%rbp)
jmp 0x8afd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x118(%rbp)
movl %eax, -0x11c(%rbp)
jmp 0x8af4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x118(%rbp)
movl %eax, -0x11c(%rbp)
jmp 0x8aeb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x118(%rbp)
movl %eax, -0x11c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x31a0
leaq -0x50(%rbp), %rdi
callq 0x31a0
leaq -0x70(%rbp), %rdi
callq 0x31a0
leaq -0x90(%rbp), %rdi
callq 0x31a0
leaq -0xb0(%rbp), %rdi
callq 0x31a0
leaq -0xd0(%rbp), %rdi
callq 0x31a0
leaq -0xf0(%rbp), %rdi
callq 0x31a0
leaq -0x110(%rbp), %rdi
callq 0x31a0
movq -0x118(%rbp), %rdi
callq 0x3420
nopw %cs:(%rax,%rax)
// File: AndrewAlbert[P]Compiler-Theory/SourceCode/parser.cpp
// Function: Parser::ReportError(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Parser::ReportError(string message){
	generator->stopCodeGeneration();
	error_queue.push("Error: line - " + to_string(currentLine) + "\n\t" + message + "\n\tFound: " + textLine + " " + token->ascii);
	error = true;
	return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x140, %rsp            # imm = 0x140
movq %rsi, -0x140(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x130(%rbp)
movq %rax, %rcx
movq %rcx, -0x138(%rbp)
movq 0x98(%rax), %rdi
callq 0x19570
movq -0x130(%rbp), %rax
movl 0x78(%rax), %esi
leaq -0x110(%rbp), %rdi
movq %rdi, -0x128(%rbp)
callq 0x123d0
movq -0x128(%rbp), %rdx
leaq 0x1c447(%rip), %rsi     # 0x2550d
leaq -0xf0(%rbp), %rdi
callq 0x12380
jmp 0x90d4
leaq 0x1dba4(%rip), %rdx     # 0x26c7f
leaq -0xd0(%rbp), %rdi
leaq -0xf0(%rbp), %rsi
callq 0x12330
jmp 0x90f0
movq -0x140(%rbp), %rdx
leaq -0xb0(%rbp), %rdi
leaq -0xd0(%rbp), %rsi
callq 0x122e0
jmp 0x910c
leaq 0x1c3e9(%rip), %rdx     # 0x254fc
leaq -0x90(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x12330
jmp 0x9128
movq -0x138(%rbp), %rdx
addq $0x58, %rdx
leaq -0x70(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x122e0
jmp 0x9145
leaq 0x1c3d8(%rip), %rdx     # 0x25524
leaq -0x50(%rbp), %rdi
leaq -0x70(%rbp), %rsi
callq 0x12330
jmp 0x915b
movq -0x138(%rbp), %rax
movq 0x80(%rax), %rdx
leaq -0x30(%rbp), %rdi
leaq -0x50(%rbp), %rsi
callq 0x122e0
jmp 0x9178
movq -0x130(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x122b0
jmp 0x918a
leaq -0x30(%rbp), %rdi
callq 0x31a0
leaq -0x50(%rbp), %rdi
callq 0x31a0
leaq -0x70(%rbp), %rdi
callq 0x31a0
leaq -0x90(%rbp), %rdi
callq 0x31a0
leaq -0xb0(%rbp), %rdi
callq 0x31a0
leaq -0xd0(%rbp), %rdi
callq 0x31a0
leaq -0xf0(%rbp), %rdi
callq 0x31a0
leaq -0x110(%rbp), %rdi
callq 0x31a0
movq -0x138(%rbp), %rax
movb $0x1, 0x51(%rax)
addq $0x140, %rsp            # imm = 0x140
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x118(%rbp)
movl %eax, -0x11c(%rbp)
jmp 0x92e7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x118(%rbp)
movl %eax, -0x11c(%rbp)
jmp 0x92db
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x118(%rbp)
movl %eax, -0x11c(%rbp)
jmp 0x92cf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x118(%rbp)
movl %eax, -0x11c(%rbp)
jmp 0x92c3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x118(%rbp)
movl %eax, -0x11c(%rbp)
jmp 0x92b7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x118(%rbp)
movl %eax, -0x11c(%rbp)
jmp 0x92ae
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x118(%rbp)
movl %eax, -0x11c(%rbp)
jmp 0x92a5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x118(%rbp)
movl %eax, -0x11c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x31a0
leaq -0x50(%rbp), %rdi
callq 0x31a0
leaq -0x70(%rbp), %rdi
callq 0x31a0
leaq -0x90(%rbp), %rdi
callq 0x31a0
leaq -0xb0(%rbp), %rdi
callq 0x31a0
leaq -0xd0(%rbp), %rdi
callq 0x31a0
leaq -0xf0(%rbp), %rdi
callq 0x31a0
leaq -0x110(%rbp), %rdi
callq 0x31a0
movq -0x118(%rbp), %rdi
callq 0x3420
nop
// File: 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
movq %rsp, %rbp
subq $0xf0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0xc0(%rbp)
movl $0x101, %esi            # imm = 0x101
callq 0x9300
testb $0x1, %al
jne 0x9dcd
jmp 0xa003
leaq -0x30(%rbp), %rdi
movq %rdi, -0xd0(%rbp)
callq 0x3370
movq -0xc0(%rbp), %rdi
movq -0xd0(%rbp), %rsi
callq 0xa800
movb %al, -0xc1(%rbp)
jmp 0x9df8
movb -0xc1(%rbp), %al
testb $0x1, %al
jne 0x9e07
jmp 0x9f50
movq -0xc0(%rbp), %rax
movq 0x90(%rax), %rax
movq %rax, -0xd8(%rbp)
leaq 0x1b82c(%rip), %rsi     # 0x2564f
leaq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rdx
callq 0x124f0
jmp 0x9e32
movq -0xd8(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x189d0
jmp 0x9e44
leaq -0x60(%rbp), %rdi
callq 0x31a0
movq -0xc0(%rbp), %rdi
movl $0x102, %esi            # imm = 0x102
callq 0x9300
movb %al, -0xd9(%rbp)
jmp 0x9e66
movb -0xd9(%rbp), %al
testb $0x1, %al
jne 0x9e72
jmp 0x9ead
movb $0x1, -0x1(%rbp)
movl $0x1, -0x64(%rbp)
jmp 0x9fed
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x9ff8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x31a0
jmp 0x9ff8
leaq -0x89(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0x3430
movq -0xe8(%rbp), %rdx
leaq 0x1b78a(%rip), %rsi     # 0x25658
leaq -0x88(%rbp), %rdi
callq 0x62d0
jmp 0x9edc
movq -0xc0(%rbp), %rdi
leaq -0x88(%rbp), %rsi
callq 0x9060
jmp 0x9ef1
leaq -0x88(%rbp), %rdi
callq 0x31a0
leaq -0x89(%rbp), %rdi
callq 0x32e0
movb $0x0, -0x1(%rbp)
movl $0x1, -0x64(%rbp)
jmp 0x9fed
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x9f3f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x31a0
leaq -0x89(%rbp), %rdi
callq 0x32e0
jmp 0x9ff8
leaq -0xb1(%rbp), %rdi
movq %rdi, -0xf0(%rbp)
callq 0x3430
movq -0xf0(%rbp), %rdx
leaq 0x1b70e(%rip), %rsi     # 0x2567f
leaq -0xb0(%rbp), %rdi
callq 0x62d0
jmp 0x9f7f
movq -0xc0(%rbp), %rdi
leaq -0xb0(%rbp), %rsi
callq 0x9060
jmp 0x9f94
leaq -0xb0(%rbp), %rdi
callq 0x31a0
leaq -0xb1(%rbp), %rdi
callq 0x32e0
movb $0x0, -0x1(%rbp)
movl $0x1, -0x64(%rbp)
jmp 0x9fed
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x9fdf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0xb0(%rbp), %rdi
callq 0x31a0
leaq -0xb1(%rbp), %rdi
callq 0x32e0
jmp 0x9ff8
leaq -0x30(%rbp), %rdi
callq 0x31a0
jmp 0xa007
leaq -0x30(%rbp), %rdi
callq 0x31a0
jmp 0xa015
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xf0, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x3420
nop
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x60(%rbp)
movq 0x80(%rax), %rsi
leaq -0x38(%rbp), %rdi
callq 0x3130
movq -0x60(%rbp), %rdi
movl $0x11c, %esi            # imm = 0x11C
callq 0x9300
movb %al, -0x51(%rbp)
jmp 0xa83b
movb -0x51(%rbp), %al
andb $0x1, %al
movb %al, -0x39(%rbp)
testb $0x1, -0x39(%rbp)
je 0xa87c
movq -0x18(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x3050
jmp 0xa858
movb $0x1, -0x1(%rbp)
movl $0x1, -0x50(%rbp)
jmp 0xa887
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x31a0
jmp 0xa89b
movb $0x0, -0x1(%rbp)
movl $0x1, -0x50(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x31a0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x3420
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x78(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x3430
movq -0x70(%rbp), %rdx
leaq 0x1bff2(%rip), %rsi     # 0x26c81
leaq -0x30(%rbp), %rdi
callq 0x62d0
jmp 0xac9a
leaq -0x31(%rbp), %rdi
callq 0x32e0
movq -0x78(%rbp), %rdi
callq 0xcf90
movb %al, -0x79(%rbp)
jmp 0xacb1
movb -0x79(%rbp), %al
testb $0x1, %al
jne 0xacba
jmp 0xacf5
movb $0x1, -0x1(%rbp)
movl $0x1, -0x48(%rbp)
jmp 0xadcd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x31(%rbp), %rdi
callq 0x32e0
jmp 0xaded
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0xade4
movq -0x78(%rbp), %rdi
callq 0xe2b0
movb %al, -0x7a(%rbp)
jmp 0xad03
movb -0x7a(%rbp), %al
testb $0x1, %al
jne 0xad0c
jmp 0xad1c
movb $0x1, -0x1(%rbp)
movl $0x1, -0x48(%rbp)
jmp 0xadcd
movq -0x78(%rbp), %rdi
callq 0xef80
movb %al, -0x7b(%rbp)
jmp 0xad2a
movb -0x7b(%rbp), %al
testb $0x1, %al
jne 0xad33
jmp 0xad43
movb $0x1, -0x1(%rbp)
movl $0x1, -0x48(%rbp)
jmp 0xadcd
movq -0x78(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0xefd0
movb %al, -0x7c(%rbp)
jmp 0xad55
movb -0x7c(%rbp), %al
testb $0x1, %al
jne 0xad5e
jmp 0xad6b
movb $0x1, -0x1(%rbp)
movl $0x1, -0x48(%rbp)
jmp 0xadcd
leaq -0x68(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3130
jmp 0xad7a
movq -0x78(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0xc000
movb %al, -0x7d(%rbp)
jmp 0xad8c
leaq -0x68(%rbp), %rdi
callq 0x31a0
movb -0x7d(%rbp), %al
testb $0x1, %al
jne 0xad9e
jmp 0xadc2
movb $0x1, -0x1(%rbp)
movl $0x1, -0x48(%rbp)
jmp 0xadcd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x31a0
jmp 0xade4
movb $0x0, -0x1(%rbp)
movl $0x1, -0x48(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x31a0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x80, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x31a0
movq -0x40(%rbp), %rdi
callq 0x3420
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movb %cl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x68(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movb -0x21(%rbp), %al
andb $0x1, %al
movzbl %al, %ecx
callq 0xb260
testb $0x1, %al
jne 0xae41
jmp 0xaece
movq -0x68(%rbp), %rdi
callq 0xb730
testb $0x1, %al
jne 0xae50
jmp 0xae56
movb $0x1, -0x1(%rbp)
jmp 0xaed2
leaq -0x49(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x3430
movq -0x70(%rbp), %rdx
leaq 0x1ab6c(%rip), %rsi     # 0x259da
leaq -0x48(%rbp), %rdi
callq 0x62d0
jmp 0xae79
movq -0x68(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x88a0
jmp 0xae88
leaq -0x48(%rbp), %rdi
callq 0x31a0
leaq -0x49(%rbp), %rdi
callq 0x32e0
movb $0x1, -0x1(%rbp)
jmp 0xaed2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0xaec3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x31a0
leaq -0x49(%rbp), %rdi
callq 0x32e0
jmp 0xaedd
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x70, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x3420
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movl $0x10a, %esi            # imm = 0x10A
callq 0x9300
testb $0x1, %al
jne 0xb1a8
jmp 0xb1b7
movq -0x18(%rbp), %rax
movl $0x10a, (%rax)          # imm = 0x10A
jmp 0xb245
movq -0x20(%rbp), %rdi
movl $0x10b, %esi            # imm = 0x10B
callq 0x9300
testb $0x1, %al
jne 0xb1cb
jmp 0xb1d7
movq -0x18(%rbp), %rax
movl $0x10b, (%rax)          # imm = 0x10B
jmp 0xb243
movq -0x20(%rbp), %rdi
movl $0x10c, %esi            # imm = 0x10C
callq 0x9300
testb $0x1, %al
jne 0xb1eb
jmp 0xb1f7
movq -0x18(%rbp), %rax
movl $0x10c, (%rax)          # imm = 0x10C
jmp 0xb241
movq -0x20(%rbp), %rdi
movl $0x10d, %esi            # imm = 0x10D
callq 0x9300
testb $0x1, %al
jne 0xb20b
jmp 0xb217
movq -0x18(%rbp), %rax
movl $0x10d, (%rax)          # imm = 0x10D
jmp 0xb23f
movq -0x20(%rbp), %rdi
movl $0x10e, %esi            # imm = 0x10E
callq 0x9300
testb $0x1, %al
jne 0xb22b
jmp 0xb237
movq -0x18(%rbp), %rax
movl $0x10e, (%rax)          # imm = 0x10E
jmp 0xb23d
movb $0x0, -0x1(%rbp)
jmp 0xb249
jmp 0xb23f
jmp 0xb241
jmp 0xb243
jmp 0xb245
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x50(%rbp)
movq -0x10(%rbp), %rsi
callq 0xccb0
testb $0x1, %al
jne 0xbf3a
jmp 0xbfdf
jmp 0xbf3c
movq -0x50(%rbp), %rdi
movl $0x134, %esi            # imm = 0x134
callq 0x9300
testb $0x1, %al
jne 0xbf53
jmp 0xbfdd
movq -0x50(%rbp), %rdi
movq -0x10(%rbp), %rsi
callq 0xccb0
testb $0x1, %al
jne 0xbfd8
leaq -0x31(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x3430
movq -0x58(%rbp), %rdx
leaq 0x19db3(%rip), %rsi     # 0x25d2f
leaq -0x30(%rbp), %rdi
callq 0x62d0
jmp 0xbf87
movq -0x50(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x9060
jmp 0xbf96
leaq -0x30(%rbp), %rdi
callq 0x31a0
leaq -0x31(%rbp), %rdi
callq 0x32e0
jmp 0xbfd8
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0xbfcd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x31a0
leaq -0x31(%rbp), %rdi
callq 0x32e0
jmp 0xbfe9
jmp 0xbf3c
jmp 0xbfdf
movb $0x1, %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x3420
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x90(%rbp)
movl $0x10f, %esi            # imm = 0x10F
callq 0x9300
testb $0x1, %al
jne 0xcae2
jmp 0xcae8
movb $0x1, -0x21(%rbp)
jmp 0xcaec
movb $0x0, -0x21(%rbp)
movq -0x90(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xf890
testb $0x1, %al
jne 0xcb09
jmp 0xcc00
testb $0x1, -0x21(%rbp)
je 0xcbb3
movq -0x18(%rbp), %rax
cmpl $0x10c, (%rax)          # imm = 0x10C
je 0xcbb3
movq -0x18(%rbp), %rax
cmpl $0x10a, (%rax)          # imm = 0x10A
je 0xcbb3
leaq -0x49(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x3430
movq -0x98(%rbp), %rdx
leaq 0x19990(%rip), %rsi     # 0x264e1
leaq -0x48(%rbp), %rdi
callq 0x62d0
jmp 0xcb5c
movq -0x90(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x9060
jmp 0xcb6e
leaq -0x48(%rbp), %rdi
callq 0x31a0
leaq -0x49(%rbp), %rdi
callq 0x32e0
jmp 0xcbda
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0xcba5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x31a0
leaq -0x49(%rbp), %rdi
callq 0x32e0
jmp 0xcca6
testb $0x1, -0x21(%rbp)
je 0xcbd8
movq -0x90(%rbp), %rax
movq 0x98(%rax), %rdi
movq -0x18(%rbp), %rax
movl (%rax), %esi
movq -0x20(%rbp), %rax
movl (%rax), %edx
callq 0x1be10
jmp 0xcbda
movq -0x90(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl $0x1, %r8d
movl %r8d, %ecx
callq 0xf8f0
movb $0x1, -0x1(%rbp)
jmp 0xcc98
testb $0x1, -0x21(%rbp)
je 0xcc94
leaq -0x81(%rbp), %rdi
movq %rdi, -0xa0(%rbp)
callq 0x3430
movq -0xa0(%rbp), %rdx
leaq 0x198f0(%rip), %rsi     # 0x2651b
leaq -0x80(%rbp), %rdi
callq 0x62d0
jmp 0xcc36
movq -0x90(%rbp), %rdi
leaq -0x80(%rbp), %rsi
callq 0x88a0
jmp 0xcc48
leaq -0x80(%rbp), %rdi
callq 0x31a0
leaq -0x81(%rbp), %rdi
callq 0x32e0
movb $0x1, -0x1(%rbp)
jmp 0xcc98
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0xcc86
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x31a0
leaq -0x81(%rbp), %rdi
callq 0x32e0
jmp 0xcca6
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xa0, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x3420
nop
// File: AndrewAlbert[P]Compiler-Theory/SourceCode/parser.cpp
// Function: Parser::ReturnStatement()
bool Parser::ReturnStatement(){
	if(CheckToken(T_RETURN)){
		generator->ProcedureReturn();
		return true;
	}
	else return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movl $0x114, %esi            # imm = 0x114
callq 0x9300
testb $0x1, %al
jne 0xefa4
jmp 0xefba
movq -0x18(%rbp), %rax
movq 0x98(%rax), %rdi
callq 0x1e550
movb $0x1, -0x1(%rbp)
jmp 0xefbe
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: AndrewAlbert[P]Compiler-Theory/SourceCode/parser.cpp
// Function: Parser::ArithOp(int&, int&)
bool Parser::ArithOp(int &type, int &size){
	if( Relation(type, size) ){
		ArithOpPrime(type, size, true, true);
		return true;
	}
	else return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0xff40
testb $0x1, %al
jne 0xf8bf
jmp 0xf8df
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl $0x1, %r8d
movl %r8d, %ecx
callq 0xffb0
movb $0x1, -0x1(%rbp)
jmp 0xf8e3
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nop
// File: AndrewAlbert[P]Compiler-Theory/SourceCode/parser.cpp
// Function: Parser::Relation(int&, int&)
bool Parser::Relation(int &type, int &size){
	if( Term(type, size) ){
		//Get relational operator if one exists. All relational operators return type bool.
		if( RelationPrime(type, size, true, true) ) type = TYPE_BOOL;
		return true;
	}
	else return false; 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x104e0
testb $0x1, %al
jne 0xff6f
jmp 0xff9f
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl $0x1, %r8d
movl %r8d, %ecx
callq 0x10540
testb $0x1, %al
jne 0xff8f
jmp 0xff99
movq -0x18(%rbp), %rax
movl $0x10c, (%rax)          # imm = 0x10C
movb $0x1, -0x1(%rbp)
jmp 0xffa3
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nop
// File: AndrewAlbert[P]Compiler-Theory/SourceCode/parser.cpp
// Function: Parser::Term(int&, int&)
bool Parser::Term(int &type, int &size){
	if(Factor(type, size)){
		TermPrime(type, size, true, true);
		return true;
	}
	else return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x28(%rbp)
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
callq 0x10a30
testb $0x1, %al
jne 0x1050f
jmp 0x1052f
movq -0x28(%rbp), %rdi
movq -0x18(%rbp), %rsi
movq -0x20(%rbp), %rdx
movl $0x1, %r8d
movl %r8d, %ecx
callq 0x10ec0
movb $0x1, -0x1(%rbp)
jmp 0x10533
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
movq 0x80(%rax), %rsi
leaq -0x30(%rbp), %rdi
callq 0x3130
movq -0x90(%rbp), %rdi
movl $0x10a, %esi            # imm = 0x10A
callq 0x9300
movb %al, -0x85(%rbp)
jmp 0x11423
movb -0x85(%rbp), %al
testb $0x1, %al
jne 0x11432
jmp 0x114b8
movq -0x90(%rbp), %rax
movq 0x98(%rax), %rax
movq %rax, -0x98(%rbp)
leaq -0x80(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3130
jmp 0x11456
movq -0x98(%rbp), %rsi
leaq -0x60(%rbp), %rdi
leaq -0x80(%rbp), %rdx
movl $0x10a, %ecx            # imm = 0x10A
callq 0x1c140
jmp 0x11471
leaq -0x60(%rbp), %rdi
callq 0x31a0
leaq -0x80(%rbp), %rdi
callq 0x31a0
movb $0x1, -0x1(%rbp)
movl $0x1, -0x84(%rbp)
jmp 0x114c6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x114dd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x31a0
jmp 0x114dd
movb $0x0, -0x1(%rbp)
movl $0x1, -0x84(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x31a0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xa0, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x31a0
movq -0x38(%rbp), %rdi
callq 0x3420
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
movq 0x80(%rax), %rsi
leaq -0x30(%rbp), %rdi
callq 0x3130
movq -0x90(%rbp), %rdi
movl $0x10b, %esi            # imm = 0x10B
callq 0x9300
movb %al, -0x85(%rbp)
jmp 0x11533
movb -0x85(%rbp), %al
testb $0x1, %al
jne 0x11542
jmp 0x115c8
movq -0x90(%rbp), %rax
movq 0x98(%rax), %rax
movq %rax, -0x98(%rbp)
leaq -0x80(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3130
jmp 0x11566
movq -0x98(%rbp), %rsi
leaq -0x60(%rbp), %rdi
leaq -0x80(%rbp), %rdx
movl $0x10b, %ecx            # imm = 0x10B
callq 0x1c140
jmp 0x11581
leaq -0x60(%rbp), %rdi
callq 0x31a0
leaq -0x80(%rbp), %rdi
callq 0x31a0
movb $0x1, -0x1(%rbp)
movl $0x1, -0x84(%rbp)
jmp 0x115d6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x115ed
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x31a0
jmp 0x115ed
movb $0x0, -0x1(%rbp)
movl $0x1, -0x84(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x31a0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xa0, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x31a0
movq -0x38(%rbp), %rdi
callq 0x3420
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
movq 0x80(%rax), %rsi
leaq -0x30(%rbp), %rdi
callq 0x3130
movq -0x90(%rbp), %rdi
movl $0x10d, %esi            # imm = 0x10D
callq 0x9300
movb %al, -0x85(%rbp)
jmp 0x11de3
movb -0x85(%rbp), %al
testb $0x1, %al
jne 0x11df2
jmp 0x11e78
movq -0x90(%rbp), %rax
movq 0x98(%rax), %rax
movq %rax, -0x98(%rbp)
leaq -0x80(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3130
jmp 0x11e16
movq -0x98(%rbp), %rsi
leaq -0x60(%rbp), %rdi
leaq -0x80(%rbp), %rdx
movl $0x10d, %ecx            # imm = 0x10D
callq 0x1c140
jmp 0x11e31
leaq -0x60(%rbp), %rdi
callq 0x31a0
leaq -0x80(%rbp), %rdi
callq 0x31a0
movb $0x1, -0x1(%rbp)
movl $0x1, -0x84(%rbp)
jmp 0x11e86
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x11e9d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x31a0
jmp 0x11e9d
movb $0x0, -0x1(%rbp)
movl $0x1, -0x84(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x31a0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xa0, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x31a0
movq -0x38(%rbp), %rdi
callq 0x3420
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0xa0, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x90(%rbp)
movq 0x80(%rax), %rsi
leaq -0x30(%rbp), %rdi
callq 0x3130
movq -0x90(%rbp), %rdi
movl $0x10e, %esi            # imm = 0x10E
callq 0x9300
movb %al, -0x85(%rbp)
jmp 0x11ef3
movb -0x85(%rbp), %al
testb $0x1, %al
jne 0x11f02
jmp 0x11f88
movq -0x90(%rbp), %rax
movq 0x98(%rax), %rax
movq %rax, -0x98(%rbp)
leaq -0x80(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x3130
jmp 0x11f26
movq -0x98(%rbp), %rsi
leaq -0x60(%rbp), %rdi
leaq -0x80(%rbp), %rdx
movl $0x10e, %ecx            # imm = 0x10E
callq 0x1c140
jmp 0x11f41
leaq -0x60(%rbp), %rdi
callq 0x31a0
leaq -0x80(%rbp), %rdi
callq 0x31a0
movb $0x1, -0x1(%rbp)
movl $0x1, -0x84(%rbp)
jmp 0x11f96
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x11fad
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x31a0
jmp 0x11fad
movb $0x0, -0x1(%rbp)
movl $0x1, -0x84(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x31a0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0xa0, %rsp
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x31a0
movq -0x38(%rbp), %rdi
callq 0x3420
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xd8(%rbp)
movq 0x80(%rax), %rsi
leaq -0x30(%rbp), %rdi
callq 0x3130
movq -0xd8(%rbp), %rdi
movl $0x115, %esi            # imm = 0x115
callq 0x9300
movb %al, -0xca(%rbp)
jmp 0x12003
movb -0xca(%rbp), %al
testb $0x1, %al
jne 0x12012
jmp 0x120e4
movq -0xd8(%rbp), %rax
movq 0x98(%rax), %rax
movq %rax, -0xe8(%rbp)
leaq -0x81(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0x3430
movq -0xe0(%rbp), %rdx
leaq 0x1498d(%rip), %rsi     # 0x269d5
leaq -0x80(%rbp), %rdi
callq 0x62d0
jmp 0x12053
movq -0xe8(%rbp), %rsi
leaq -0x60(%rbp), %rdi
leaq -0x80(%rbp), %rdx
movl $0x10c, %ecx            # imm = 0x10C
callq 0x1c140
jmp 0x1206e
leaq -0x60(%rbp), %rdi
callq 0x31a0
leaq -0x80(%rbp), %rdi
callq 0x31a0
leaq -0x81(%rbp), %rdi
callq 0x32e0
movb $0x1, -0x1(%rbp)
movl $0x1, -0x88(%rbp)
jmp 0x121e7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x121fe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x120d3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x31a0
leaq -0x81(%rbp), %rdi
callq 0x32e0
jmp 0x121fe
movq -0xd8(%rbp), %rdi
movl $0x116, %esi            # imm = 0x116
callq 0x9300
movb %al, -0xe9(%rbp)
jmp 0x120fd
movb -0xe9(%rbp), %al
testb $0x1, %al
jne 0x1210c
jmp 0x121d9
movq -0xd8(%rbp), %rax
movq 0x98(%rax), %rax
movq %rax, -0x100(%rbp)
leaq -0xc9(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
callq 0x3430
movq -0xf8(%rbp), %rdx
leaq 0x14895(%rip), %rsi     # 0x269d7
leaq -0xc8(%rbp), %rdi
callq 0x62d0
jmp 0x12150
movq -0x100(%rbp), %rsi
leaq -0xa8(%rbp), %rdi
leaq -0xc8(%rbp), %rdx
movl $0x10c, %ecx            # imm = 0x10C
callq 0x1c140
jmp 0x12171
leaq -0xa8(%rbp), %rdi
callq 0x31a0
leaq -0xc8(%rbp), %rdi
callq 0x31a0
leaq -0xc9(%rbp), %rdi
callq 0x32e0
movb $0x1, -0x1(%rbp)
movl $0x1, -0x88(%rbp)
jmp 0x121e7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x121cb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0x31a0
leaq -0xc9(%rbp), %rdi
callq 0x32e0
jmp 0x121fe
movb $0x0, -0x1(%rbp)
movl $0x1, -0x88(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x31a0
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
leaq -0x30(%rbp), %rdi
callq 0x31a0
movq -0x38(%rbp), %rdi
callq 0x3420
// File: 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
movq %rsp, %rbp
subq $0x40, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movq %rdi, %rax
movq %rax, -0x40(%rbp)
callq 0x161a0
movq -0x30(%rbp), %rdi
addq $0x30, %rdi
movq %rdi, -0x38(%rbp)
callq 0x161a0
movq -0x30(%rbp), %rdi
addq $0x60, %rdi
movq %rdi, -0x28(%rbp)
callq 0x3370
movq -0x28(%rbp), %rdi
leaq 0x114dc(%rip), %rsi     # 0x26c81
callq 0x3360
jmp 0x157ac
testb $0x1, -0x9(%rbp)
je 0x157eb
movq -0x40(%rbp), %rax
movl $0x0, 0x80(%rax)
jmp 0x157f9
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x31a0
movq -0x38(%rbp), %rdi
callq 0x161c0
movq -0x30(%rbp), %rdi
callq 0x161c0
jmp 0x157ff
movq -0x40(%rbp), %rax
movl $0x2, 0x80(%rax)
addq $0x40, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x3420
nopl (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x50, %rsp
movq %rcx, -0x50(%rbp)
movq %rsi, -0x48(%rbp)
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x40(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x161e0
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdi
addq $0x30, %rdi
callq 0x16200
movq -0x40(%rbp), %rdi
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
addq $0x30, %rdi
callq 0x16260
movq %rax, -0x38(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x16230
testb $0x1, %al
jne 0x158f5
jmp 0x158ff
xorl %eax, %eax
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
movq -0x50(%rbp), %rax
cmpl $0x11e, (%rax)          # imm = 0x11E
je 0x15950
movq -0x50(%rbp), %rax
movq -0x40(%rbp), %rcx
movl 0x80(%rcx), %ecx
movl %ecx, 0x44(%rax)
cmpl $0x0, 0x4(%rax)
jle 0x1593b
movq -0x40(%rbp), %rax
movq -0x50(%rbp), %rcx
movl 0x4(%rcx), %ecx
addl 0x80(%rax), %ecx
movl %ecx, 0x80(%rax)
jmp 0x1594e
movq -0x40(%rbp), %rax
movl 0x80(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x80(%rax)
jmp 0x15950
testb $0x1, -0x11(%rbp)
je 0x1596f
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdi
callq 0x16290
movq -0x50(%rbp), %rsi
movq %rax, %rdi
callq 0x16370
movq -0x48(%rbp), %rsi
movq -0x40(%rbp), %rdi
addq $0x30, %rdi
callq 0x16290
movq -0x50(%rbp), %rsi
movq %rax, %rdi
callq 0x16370
ud2
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rsi, -0x58(%rbp)
movb %dl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
andb $0x1, %al
movb %al, -0x19(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x161e0
testb $0x1, -0x19(%rbp)
je 0x15a07
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rsi
callq 0x16200
movq -0x50(%rbp), %rdi
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq %rax, -0x28(%rbp)
callq 0x16260
movq %rax, -0x38(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x16230
testb $0x1, %al
jne 0x159fb
jmp 0x15a01
movb $0x1, -0x1(%rbp)
jmp 0x15a52
movb $0x0, -0x1(%rbp)
jmp 0x15a52
movq -0x50(%rbp), %rdi
movq -0x58(%rbp), %rsi
addq $0x30, %rdi
callq 0x16200
movq -0x50(%rbp), %rdi
movq %rax, -0x40(%rbp)
movq -0x40(%rbp), %rax
movq %rax, -0x28(%rbp)
addq $0x30, %rdi
callq 0x16260
movq %rax, -0x48(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x16230
testb $0x1, %al
jne 0x15a48
jmp 0x15a4e
movb $0x1, -0x1(%rbp)
jmp 0x15a52
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdx, -0x70(%rbp)
movq %rdi, -0x80(%rbp)
movq %rdi, %rax
movq %rax, -0x78(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x68(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x161e0
movq -0x70(%rbp), %rsi
movq -0x68(%rbp), %rdi
addq $0x30, %rdi
callq 0x16200
movq -0x68(%rbp), %rdi
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq %rax, -0x20(%rbp)
addq $0x30, %rdi
callq 0x16260
movq %rax, -0x30(%rbp)
leaq -0x20(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x16230
testb $0x1, %al
jne 0x15ad8
jmp 0x15af3
leaq -0x20(%rbp), %rdi
callq 0x163d0
movq -0x80(%rbp), %rdi
movq %rax, %rsi
addq $0x20, %rsi
callq 0x12770
jmp 0x15b70
movq -0x80(%rbp), %rdi
movb $0x0, -0x31(%rbp)
callq 0x126b0
movq -0x80(%rbp), %rax
movl $0x15e, (%rax)          # imm = 0x15E
leaq -0x50(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x12830
movq -0x80(%rbp), %rdi
movq -0x88(%rbp), %rsi
addq $0x8, %rdi
callq 0x163f0
jmp 0x15b30
movb $0x1, -0x31(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x12930
testb $0x1, -0x31(%rbp)
jne 0x15b6e
jmp 0x15b65
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x12930
movq -0x80(%rbp), %rdi
callq 0x12800
jmp 0x15b7d
movq -0x80(%rbp), %rdi
callq 0x12800
jmp 0x15b70
movq -0x78(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x3420
nopw %cs:(%rax,%rax)
// File: AndrewAlbert[P]Compiler-Theory/SourceCode/scopeTracker.cpp
// Function: scopeTracker::scopeTracker(bool)
scopeTracker::scopeTracker(bool debug_input){
	debug = debug_input;
	tmpPtr = nullptr;
	curPtr = nullptr;
	outermost = nullptr;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movb -0x9(%rbp), %cl
andb $0x1, %cl
movb %cl, 0x18(%rax)
movq $0x0, 0x8(%rax)
movq $0x0, (%rax)
movq $0x0, 0x10(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, (%rax)
je 0x182c9
movq -0x20(%rbp), %rax
movq (%rax), %rcx
movq %rcx, 0x8(%rax)
movl $0x90, %edi
callq 0x3290
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x28(%rbp)
xorl %esi, %esi
callq 0x15750
jmp 0x18292
movq -0x20(%rbp), %rax
movq -0x28(%rbp), %rcx
movq %rcx, (%rax)
movq 0x8(%rax), %rcx
movq (%rax), %rax
movq %rcx, 0x88(%rax)
jmp 0x18327
movq -0x28(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl $0x90, %esi
callq 0x32a0
jmp 0x1832d
movl $0x90, %edi
callq 0x3290
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movl $0x1, %esi
callq 0x15750
jmp 0x182e9
movq -0x20(%rbp), %rax
movq -0x30(%rbp), %rcx
movq %rcx, (%rax)
movq 0x8(%rax), %rdx
movq (%rax), %rcx
movq %rdx, 0x88(%rcx)
movq (%rax), %rcx
movq %rcx, 0x10(%rax)
jmp 0x18327
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x10(%rbp)
movl %eax, -0x14(%rbp)
movl $0x90, %esi
callq 0x32a0
jmp 0x1832d
addq $0x30, %rsp
popq %rbp
retq
movq -0x10(%rbp), %rdi
callq 0x3420
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
cmpq $0x0, (%rax)
je 0x183af
movq -0x10(%rbp), %rax
testb $0x1, 0x18(%rax)
je 0x18370
movq -0x10(%rbp), %rax
movq (%rax), %rdi
callq 0x15b90
movq -0x10(%rbp), %rax
movq (%rax), %rcx
movq %rcx, 0x8(%rax)
movq (%rax), %rcx
movq 0x88(%rcx), %rcx
movq %rcx, (%rax)
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, %rax
je 0x183ad
movq -0x18(%rbp), %rdi
callq 0x15810
movq -0x18(%rbp), %rdi
movl $0x90, %esi
callq 0x32a0
jmp 0x183dd
movq -0x10(%rbp), %rax
testb $0x1, 0x18(%rax)
je 0x183db
movq 0x1ac10(%rip), %rdi     # 0x32fd0
leaq 0xe8db(%rip), %rsi      # 0x26ca2
callq 0x3270
movq %rax, %rdi
movq 0x1abe2(%rip), %rsi     # 0x32fb8
callq 0x32c0
jmp 0x183dd
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdx, -0xd8(%rbp)
movq %rsi, -0xd0(%rbp)
movb %cl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xc8(%rbp)
cmpq $0x0, (%rax)
je 0x18569
movq -0xd0(%rbp), %rsi
movq -0xc8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0xf0(%rbp)
leaq -0x48(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0x3130
movq -0xf0(%rbp), %rdi
movq -0xe8(%rbp), %rsi
xorl %edx, %edx
callq 0x15990
movb %al, -0xd9(%rbp)
jmp 0x18476
movb -0xd9(%rbp), %al
xorb $-0x1, %al
movb %al, -0xf1(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x31a0
movb -0xf1(%rbp), %al
testb $0x1, %al
jne 0x1849c
jmp 0x18563
movq -0xd0(%rbp), %rsi
movq -0xc8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x100(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x3130
movq -0xd8(%rbp), %rsi
movb -0x21(%rbp), %al
movb %al, -0xf2(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x12770
jmp 0x184db
movq -0x100(%rbp), %rdi
movb -0xf2(%rbp), %al
movzbl %al, %edx
andl $0x1, %edx
leaq -0x78(%rbp), %rsi
leaq -0xc0(%rbp), %rcx
callq 0x15880
jmp 0x18500
leaq -0xc0(%rbp), %rdi
callq 0x12800
leaq -0x78(%rbp), %rdi
callq 0x31a0
movb $0x1, -0x1(%rbp)
jmp 0x1856d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x31a0
jmp 0x1857b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x18558
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x12800
leaq -0x78(%rbp), %rdi
callq 0x31a0
jmp 0x1857b
movb $0x0, -0x1(%rbp)
jmp 0x1856d
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq -0x50(%rbp), %rdi
callq 0x3420
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x100, %rsp            # imm = 0x100
movq %rdx, -0xd8(%rbp)
movq %rsi, -0xd0(%rbp)
movb %cl, %al
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq %rdx, -0x20(%rbp)
andb $0x1, %al
movb %al, -0x21(%rbp)
movq -0x10(%rbp), %rax
movq (%rax), %rax
movq 0x88(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, -0x30(%rbp)
je 0x18705
movq -0xd0(%rbp), %rsi
movq -0x30(%rbp), %rax
movq %rax, -0xf0(%rbp)
leaq -0x50(%rbp), %rdi
movq %rdi, -0xe8(%rbp)
callq 0x3130
movq -0xf0(%rbp), %rdi
movq -0xe8(%rbp), %rsi
xorl %edx, %edx
callq 0x15990
movb %al, -0xd9(%rbp)
jmp 0x18618
movb -0xd9(%rbp), %al
xorb $-0x1, %al
movb %al, -0xf1(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x31a0
movb -0xf1(%rbp), %al
testb $0x1, %al
jne 0x1863e
jmp 0x186ff
movq -0xd0(%rbp), %rsi
movq -0x30(%rbp), %rax
movq %rax, -0x100(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x3130
movq -0xd8(%rbp), %rsi
movb -0x21(%rbp), %al
movb %al, -0xf2(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0x12770
jmp 0x18677
movq -0x100(%rbp), %rdi
movb -0xf2(%rbp), %al
movzbl %al, %edx
andl $0x1, %edx
leaq -0x80(%rbp), %rsi
leaq -0xc8(%rbp), %rcx
callq 0x15880
jmp 0x1869c
leaq -0xc8(%rbp), %rdi
callq 0x12800
leaq -0x80(%rbp), %rdi
callq 0x31a0
movb $0x1, -0x1(%rbp)
jmp 0x18709
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x31a0
jmp 0x18717
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x186f4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0xc8(%rbp), %rdi
callq 0x12800
leaq -0x80(%rbp), %rdi
callq 0x31a0
jmp 0x18717
movb $0x0, -0x1(%rbp)
jmp 0x18709
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x100, %rsp            # imm = 0x100
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x3420