LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: Blaze2305[P]Compiler-Design-2021-Assignment/src/Parser/Parser.cpp
// Function: Parser::parseReadStmt()
void Parser::parseReadStmt(){
	tabNum+=1;
	printParseEnters(tabNum,tabChar,"parseReadStmt");
	accept(Read);
	accept(Identifier);
	tabNum-=1;
	printParseExits(tabNum,tabChar,"parseReadStmt");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movl 0x12e6f(%rip), %eax     # 0x222cc
incl %eax
movl %eax, 0x12e67(%rip)     # 0x222cc
movl 0x12e61(%rip), %eax     # 0x222cc
movl %eax, -0x78(%rbp)
movb 0x12e54(%rip), %al      # 0x222c8
movb %al, -0x71(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x3510
movq -0x70(%rbp), %rdx
leaq 0x9e91(%rip), %rsi      # 0x19320
leaq -0x28(%rbp), %rdi
callq 0xb640
jmp 0xf49a
movl -0x78(%rbp), %edi
movb -0x71(%rbp), %al
movsbl %al, %esi
leaq -0x28(%rbp), %rdx
callq 0x15530
jmp 0xf4ae
leaq -0x28(%rbp), %rdi
callq 0x3558
leaq -0x29(%rbp), %rdi
callq 0x3300
movq -0x80(%rbp), %rdi
movl $0x13, %esi
callq 0xd670
movq -0x80(%rbp), %rdi
xorl %esi, %esi
callq 0xd670
movl 0x12ded(%rip), %eax     # 0x222cc
decl %eax
movl %eax, 0x12de5(%rip)     # 0x222cc
movl 0x12ddf(%rip), %eax     # 0x222cc
movl %eax, -0x90(%rbp)
movb 0x12dcf(%rip), %al      # 0x222c8
movb %al, -0x89(%rbp)
leaq -0x61(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x3510
movq -0x88(%rbp), %rdx
leaq 0x9e03(%rip), %rsi      # 0x19320
leaq -0x60(%rbp), %rdi
callq 0xb640
jmp 0xf528
movl -0x90(%rbp), %edi
movb -0x89(%rbp), %al
movsbl %al, %esi
leaq -0x60(%rbp), %rdx
callq 0x15550
jmp 0xf542
leaq -0x60(%rbp), %rdi
callq 0x3558
leaq -0x61(%rbp), %rdi
callq 0x3300
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xf580
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3558
leaq -0x29(%rbp), %rdi
callq 0x3300
jmp 0xf5b7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xf5ae
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3558
leaq -0x61(%rbp), %rdi
callq 0x3300
movq -0x38(%rbp), %rdi
callq 0x3500
// File: Blaze2305[P]Compiler-Design-2021-Assignment/src/Parser/Parser.cpp
// Function: Parser::parsePrintStmt()
void Parser::parsePrintStmt(){
	tabNum+=1;
	printParseEnters(tabNum,tabChar,"parsePrintStmt");
	accept(Print);
	parseExp();
	tabNum-=1;
	printParseExits(tabNum,tabChar,"parsePrintStmt");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movl 0x12cef(%rip), %eax     # 0x222cc
incl %eax
movl %eax, 0x12ce7(%rip)     # 0x222cc
movl 0x12ce1(%rip), %eax     # 0x222cc
movl %eax, -0x78(%rbp)
movb 0x12cd4(%rip), %al      # 0x222c8
movb %al, -0x71(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x3510
movq -0x70(%rbp), %rdx
leaq 0x9d1f(%rip), %rsi      # 0x1932e
leaq -0x28(%rbp), %rdi
callq 0xb640
jmp 0xf61a
movl -0x78(%rbp), %edi
movb -0x71(%rbp), %al
movsbl %al, %esi
leaq -0x28(%rbp), %rdx
callq 0x15530
jmp 0xf62e
leaq -0x28(%rbp), %rdi
callq 0x3558
leaq -0x29(%rbp), %rdi
callq 0x3300
movq -0x80(%rbp), %rdi
movl $0x14, %esi
callq 0xd670
movq -0x80(%rbp), %rdi
callq 0xfaa0
movl 0x12c6f(%rip), %eax     # 0x222cc
decl %eax
movl %eax, 0x12c67(%rip)     # 0x222cc
movl 0x12c61(%rip), %eax     # 0x222cc
movl %eax, -0x90(%rbp)
movb 0x12c51(%rip), %al      # 0x222c8
movb %al, -0x89(%rbp)
leaq -0x61(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x3510
movq -0x88(%rbp), %rdx
leaq 0x9c93(%rip), %rsi      # 0x1932e
leaq -0x60(%rbp), %rdi
callq 0xb640
jmp 0xf6a6
movl -0x90(%rbp), %edi
movb -0x89(%rbp), %al
movsbl %al, %esi
leaq -0x60(%rbp), %rdx
callq 0x15550
jmp 0xf6c0
leaq -0x60(%rbp), %rdi
callq 0x3558
leaq -0x61(%rbp), %rdi
callq 0x3300
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xf6fe
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3558
leaq -0x29(%rbp), %rdi
callq 0x3300
jmp 0xf735
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xf72c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3558
leaq -0x61(%rbp), %rdi
callq 0x3300
movq -0x38(%rbp), %rdi
callq 0x3500
nop
// File: Blaze2305[P]Compiler-Design-2021-Assignment/src/Parser/Parser.cpp
// Function: Parser::parseIfStmt()
void Parser::parseIfStmt(){
	tabNum+=1;
	printParseEnters(tabNum,tabChar,"parseIfStmt");
	accept(If);
	parseBexp();
	accept(Colon);
	parseStmtList();
	parseElsePart();
	accept(End);
	tabNum-=1;
	printParseExits(tabNum,tabChar,"parseIfStmt");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movl 0x12b6f(%rip), %eax     # 0x222cc
incl %eax
movl %eax, 0x12b67(%rip)     # 0x222cc
movl 0x12b61(%rip), %eax     # 0x222cc
movl %eax, -0x78(%rbp)
movb 0x12b54(%rip), %al      # 0x222c8
movb %al, -0x71(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x3510
movq -0x70(%rbp), %rdx
leaq 0x9bae(%rip), %rsi      # 0x1933d
leaq -0x28(%rbp), %rdi
callq 0xb640
jmp 0xf79a
movl -0x78(%rbp), %edi
movb -0x71(%rbp), %al
movsbl %al, %esi
leaq -0x28(%rbp), %rdx
callq 0x15530
jmp 0xf7ae
leaq -0x28(%rbp), %rdi
callq 0x3558
leaq -0x29(%rbp), %rdi
callq 0x3300
movq -0x80(%rbp), %rdi
movl $0x10, %esi
callq 0xd670
movq -0x80(%rbp), %rdi
callq 0xfca0
movq -0x80(%rbp), %rdi
movl $0xe, %esi
callq 0xd670
movq -0x80(%rbp), %rdi
callq 0xe040
movq -0x80(%rbp), %rdi
callq 0xfeb0
movq -0x80(%rbp), %rdi
movl $0xb, %esi
callq 0xd670
movl 0x12ac1(%rip), %eax     # 0x222cc
decl %eax
movl %eax, 0x12ab9(%rip)     # 0x222cc
movl 0x12ab3(%rip), %eax     # 0x222cc
movl %eax, -0x90(%rbp)
movb 0x12aa3(%rip), %al      # 0x222c8
movb %al, -0x89(%rbp)
leaq -0x61(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x3510
movq -0x88(%rbp), %rdx
leaq 0x9af4(%rip), %rsi      # 0x1933d
leaq -0x60(%rbp), %rdi
callq 0xb640
jmp 0xf854
movl -0x90(%rbp), %edi
movb -0x89(%rbp), %al
movsbl %al, %esi
leaq -0x60(%rbp), %rdx
callq 0x15550
jmp 0xf86e
leaq -0x60(%rbp), %rdi
callq 0x3558
leaq -0x61(%rbp), %rdi
callq 0x3300
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xf8ac
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3558
leaq -0x29(%rbp), %rdi
callq 0x3300
jmp 0xf8e3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xf8da
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3558
leaq -0x61(%rbp), %rdi
callq 0x3300
movq -0x38(%rbp), %rdi
callq 0x3500
nopl (%rax)
// File: Blaze2305[P]Compiler-Design-2021-Assignment/src/Parser/Parser.cpp
// Function: Parser::parseWhileStmt()
void Parser::parseWhileStmt(){
	tabNum+=1;
	printParseEnters(tabNum,tabChar,"parseWhileStmt");
	accept(While);
	parseBexp();
	accept(Colon);
	parseStmtList();
	accept(End);
	tabNum-=1;
	printParseExits(tabNum,tabChar,"parseWhileStmt");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movl 0x129bf(%rip), %eax     # 0x222cc
incl %eax
movl %eax, 0x129b7(%rip)     # 0x222cc
movl 0x129b1(%rip), %eax     # 0x222cc
movl %eax, -0x78(%rbp)
movb 0x129a4(%rip), %al      # 0x222c8
movb %al, -0x71(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x3510
movq -0x70(%rbp), %rdx
leaq 0x9a18(%rip), %rsi      # 0x19357
leaq -0x28(%rbp), %rdi
callq 0xb640
jmp 0xf94a
movl -0x78(%rbp), %edi
movb -0x71(%rbp), %al
movsbl %al, %esi
leaq -0x28(%rbp), %rdx
callq 0x15530
jmp 0xf95e
leaq -0x28(%rbp), %rdi
callq 0x3558
leaq -0x29(%rbp), %rdi
callq 0x3300
movq -0x80(%rbp), %rdi
movl $0x12, %esi
callq 0xd670
movq -0x80(%rbp), %rdi
callq 0xfca0
movq -0x80(%rbp), %rdi
movl $0xe, %esi
callq 0xd670
movq -0x80(%rbp), %rdi
callq 0xe040
movq -0x80(%rbp), %rdi
movl $0xb, %esi
callq 0xd670
movl 0x1291a(%rip), %eax     # 0x222cc
decl %eax
movl %eax, 0x12912(%rip)     # 0x222cc
movl 0x1290c(%rip), %eax     # 0x222cc
movl %eax, -0x90(%rbp)
movb 0x128fc(%rip), %al      # 0x222c8
movb %al, -0x89(%rbp)
leaq -0x61(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x3510
movq -0x88(%rbp), %rdx
leaq 0x9967(%rip), %rsi      # 0x19357
leaq -0x60(%rbp), %rdi
callq 0xb640
jmp 0xf9fb
movl -0x90(%rbp), %edi
movb -0x89(%rbp), %al
movsbl %al, %esi
leaq -0x60(%rbp), %rdx
callq 0x15550
jmp 0xfa15
leaq -0x60(%rbp), %rdi
callq 0x3558
leaq -0x61(%rbp), %rdi
callq 0x3300
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xfa53
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3558
leaq -0x29(%rbp), %rdi
callq 0x3300
jmp 0xfa8a
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xfa81
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3558
leaq -0x61(%rbp), %rdi
callq 0x3300
movq -0x38(%rbp), %rdi
callq 0x3500
nopw %cs:(%rax,%rax)
// File: Blaze2305[P]Compiler-Design-2021-Assignment/src/Parser/Parser.cpp
// Function: Parser::parseExp()
void Parser::parseExp(){
	tabNum+=1;
	printParseEnters(tabNum,tabChar,"parseExp");
	if(checkToken(LParen)){
		accept(LParen);
		parseExp();
		accept(RParen);
	}else if(checkToken(Identifier)){
		accept(Identifier);
		parseExpA();
	}else if(checkToken(Number)){
		accept(Number);
		parseExpA();
	}
	tabNum-=1;
	printParseExits(tabNum,tabChar,"parseExp");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movl 0x1280f(%rip), %eax     # 0x222cc
incl %eax
movl %eax, 0x12807(%rip)     # 0x222cc
movl 0x12801(%rip), %eax     # 0x222cc
movl %eax, -0x78(%rbp)
movb 0x127f4(%rip), %al      # 0x222c8
movb %al, -0x71(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x3510
movq -0x70(%rbp), %rdx
leaq 0x988c(%rip), %rsi      # 0x1937b
leaq -0x28(%rbp), %rdi
callq 0xb640
jmp 0xfafa
movl -0x78(%rbp), %edi
movb -0x71(%rbp), %al
movsbl %al, %esi
leaq -0x28(%rbp), %rdx
callq 0x15530
jmp 0xfb0e
leaq -0x28(%rbp), %rdi
callq 0x3558
leaq -0x29(%rbp), %rdi
callq 0x3300
movq -0x80(%rbp), %rdi
movl $0x6, %esi
callq 0xdb20
testb $0x1, %al
jne 0xfb34
jmp 0xfb8f
movq -0x80(%rbp), %rdi
movl $0x6, %esi
callq 0xd670
movq -0x80(%rbp), %rdi
callq 0xfaa0
movq -0x80(%rbp), %rdi
movl $0x7, %esi
callq 0xd670
jmp 0xfbe5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xfb81
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3558
leaq -0x29(%rbp), %rdi
callq 0x3300
jmp 0xfc95
movq -0x80(%rbp), %rdi
xorl %esi, %esi
callq 0xdb20
testb $0x1, %al
jne 0xfba0
jmp 0xfbb6
movq -0x80(%rbp), %rdi
xorl %esi, %esi
callq 0xd670
movq -0x80(%rbp), %rdi
callq 0x101f0
jmp 0xfbe3
movq -0x80(%rbp), %rdi
movl $0x1, %esi
callq 0xdb20
testb $0x1, %al
jne 0xfbca
jmp 0xfbe1
movq -0x80(%rbp), %rdi
movl $0x1, %esi
callq 0xd670
movq -0x80(%rbp), %rdi
callq 0x101f0
jmp 0xfbe3
jmp 0xfbe5
movl 0x126e1(%rip), %eax     # 0x222cc
decl %eax
movl %eax, 0x126d9(%rip)     # 0x222cc
movl 0x126d3(%rip), %eax     # 0x222cc
movl %eax, -0x90(%rbp)
movb 0x126c3(%rip), %al      # 0x222c8
movb %al, -0x89(%rbp)
leaq -0x61(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x3510
movq -0x88(%rbp), %rdx
leaq 0x9752(%rip), %rsi      # 0x1937b
leaq -0x60(%rbp), %rdi
callq 0xb640
jmp 0xfc34
movl -0x90(%rbp), %edi
movb -0x89(%rbp), %al
movsbl %al, %esi
leaq -0x60(%rbp), %rdx
callq 0x15550
jmp 0xfc4e
leaq -0x60(%rbp), %rdi
callq 0x3558
leaq -0x61(%rbp), %rdi
callq 0x3300
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xfc8c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3558
leaq -0x61(%rbp), %rdi
callq 0x3300
movq -0x38(%rbp), %rdi
callq 0x3500
nop
// File: Blaze2305[P]Compiler-Design-2021-Assignment/src/Parser/Parser.cpp
// Function: Parser::parseBexp()
void Parser::parseBexp(){
	tabNum+=1;
	printParseEnters(tabNum,tabChar,"parseBexp");
	if(checkToken(LParen)){
		accept(LParen);
		parseBexp();
		accept(RParen);
	}else if(checkToken(Conditional)){
		accept(Conditional);
		parseBexp();
		parseBexpA();
	}else {
		parseExp();
		accept(Conditional);
		parseExp();
		parseBexpA();
	}
	tabNum-=1;
	printParseExits(tabNum,tabChar,"parseBexp");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movl 0x1260f(%rip), %eax     # 0x222cc
incl %eax
movl %eax, 0x12607(%rip)     # 0x222cc
movl 0x12601(%rip), %eax     # 0x222cc
movl %eax, -0x78(%rbp)
movb 0x125f4(%rip), %al      # 0x222c8
movb %al, -0x71(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x3510
movq -0x70(%rbp), %rdx
leaq 0x9677(%rip), %rsi      # 0x19366
leaq -0x28(%rbp), %rdi
callq 0xb640
jmp 0xfcfa
movl -0x78(%rbp), %edi
movb -0x71(%rbp), %al
movsbl %al, %esi
leaq -0x28(%rbp), %rdx
callq 0x15530
jmp 0xfd0e
leaq -0x28(%rbp), %rdi
callq 0x3558
leaq -0x29(%rbp), %rdi
callq 0x3300
movq -0x80(%rbp), %rdi
movl $0x6, %esi
callq 0xdb20
testb $0x1, %al
jne 0xfd34
jmp 0xfd8f
movq -0x80(%rbp), %rdi
movl $0x6, %esi
callq 0xd670
movq -0x80(%rbp), %rdi
callq 0xfca0
movq -0x80(%rbp), %rdi
movl $0x7, %esi
callq 0xd670
jmp 0xfdf0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xfd81
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3558
leaq -0x29(%rbp), %rdi
callq 0x3300
jmp 0xfea0
movq -0x80(%rbp), %rdi
movl $0x9, %esi
callq 0xdb20
testb $0x1, %al
jne 0xfda3
jmp 0xfdc5
movq -0x80(%rbp), %rdi
movl $0x9, %esi
callq 0xd670
movq -0x80(%rbp), %rdi
callq 0xfca0
movq -0x80(%rbp), %rdi
callq 0x10050
jmp 0xfdee
movq -0x80(%rbp), %rdi
callq 0xfaa0
movq -0x80(%rbp), %rdi
movl $0x9, %esi
callq 0xd670
movq -0x80(%rbp), %rdi
callq 0xfaa0
movq -0x80(%rbp), %rdi
callq 0x10050
jmp 0xfdf0
movl 0x124d6(%rip), %eax     # 0x222cc
decl %eax
movl %eax, 0x124ce(%rip)     # 0x222cc
movl 0x124c8(%rip), %eax     # 0x222cc
movl %eax, -0x90(%rbp)
movb 0x124b8(%rip), %al      # 0x222c8
movb %al, -0x89(%rbp)
leaq -0x61(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x3510
movq -0x88(%rbp), %rdx
leaq 0x9532(%rip), %rsi      # 0x19366
leaq -0x60(%rbp), %rdi
callq 0xb640
jmp 0xfe3f
movl -0x90(%rbp), %edi
movb -0x89(%rbp), %al
movsbl %al, %esi
leaq -0x60(%rbp), %rdx
callq 0x15550
jmp 0xfe59
leaq -0x60(%rbp), %rdi
callq 0x3558
leaq -0x61(%rbp), %rdi
callq 0x3300
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xfe97
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3558
leaq -0x61(%rbp), %rdi
callq 0x3300
movq -0x38(%rbp), %rdi
callq 0x3500
nopl (%rax)
// File: Blaze2305[P]Compiler-Design-2021-Assignment/src/Parser/Parser.cpp
// Function: Parser::parseElsePart()
void Parser::parseElsePart(){
	tabNum+=1;
	printParseEnters(tabNum,tabChar,"parseElsePart");
	if(checkToken(Else)){
		accept(Else);
		parseStmtList();
	}
	tabNum-=1;
	printParseExits(tabNum,tabChar,"parseElsePart");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movl 0x123ff(%rip), %eax     # 0x222cc
incl %eax
movl %eax, 0x123f7(%rip)     # 0x222cc
movl 0x123f1(%rip), %eax     # 0x222cc
movl %eax, -0x78(%rbp)
movb 0x123e4(%rip), %al      # 0x222c8
movb %al, -0x71(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x3510
movq -0x70(%rbp), %rdx
leaq 0x944a(%rip), %rsi      # 0x19349
leaq -0x28(%rbp), %rdi
callq 0xb640
jmp 0xff0a
movl -0x78(%rbp), %edi
movb -0x71(%rbp), %al
movsbl %al, %esi
leaq -0x28(%rbp), %rdx
callq 0x15530
jmp 0xff1e
leaq -0x28(%rbp), %rdi
callq 0x3558
leaq -0x29(%rbp), %rdi
callq 0x3300
movq -0x80(%rbp), %rdi
movl $0x11, %esi
callq 0xdb20
testb $0x1, %al
jne 0xff44
jmp 0xff8e
movq -0x80(%rbp), %rdi
movl $0x11, %esi
callq 0xd670
movq -0x80(%rbp), %rdi
callq 0xe040
jmp 0xff8e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0xff80
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3558
leaq -0x29(%rbp), %rdi
callq 0x3300
jmp 0x1003e
movl 0x12338(%rip), %eax     # 0x222cc
decl %eax
movl %eax, 0x12330(%rip)     # 0x222cc
movl 0x1232a(%rip), %eax     # 0x222cc
movl %eax, -0x90(%rbp)
movb 0x1231a(%rip), %al      # 0x222c8
movb %al, -0x89(%rbp)
leaq -0x61(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x3510
movq -0x88(%rbp), %rdx
leaq 0x9377(%rip), %rsi      # 0x19349
leaq -0x60(%rbp), %rdi
callq 0xb640
jmp 0xffdd
movl -0x90(%rbp), %edi
movb -0x89(%rbp), %al
movsbl %al, %esi
leaq -0x60(%rbp), %rdx
callq 0x15550
jmp 0xfff7
leaq -0x60(%rbp), %rdi
callq 0x3558
leaq -0x61(%rbp), %rdi
callq 0x3300
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x10035
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3558
leaq -0x61(%rbp), %rdi
callq 0x3300
movq -0x38(%rbp), %rdi
callq 0x3500
nopw (%rax,%rax)
// File: Blaze2305[P]Compiler-Design-2021-Assignment/src/Parser/Parser.cpp
// Function: Parser::parseBexpA()
void Parser::parseBexpA(){
	tabNum+=1;
	printParseEnters(tabNum,tabChar,"parseBexpA");
	if(checkToken(Conditional)){
		accept(Conditional);
		parseBexp();
		parseBexpA();
	}
	tabNum-=1;
	printParseExits(tabNum,tabChar,"parseBexpA");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movl 0x1225f(%rip), %eax     # 0x222cc
incl %eax
movl %eax, 0x12257(%rip)     # 0x222cc
movl 0x12251(%rip), %eax     # 0x222cc
movl %eax, -0x78(%rbp)
movb 0x12244(%rip), %al      # 0x222c8
movb %al, -0x71(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x3510
movq -0x70(%rbp), %rdx
leaq 0x92d1(%rip), %rsi      # 0x19370
leaq -0x28(%rbp), %rdi
callq 0xb640
jmp 0x100aa
movl -0x78(%rbp), %edi
movb -0x71(%rbp), %al
movsbl %al, %esi
leaq -0x28(%rbp), %rdx
callq 0x15530
jmp 0x100be
leaq -0x28(%rbp), %rdi
callq 0x3558
leaq -0x29(%rbp), %rdi
callq 0x3300
movq -0x80(%rbp), %rdi
movl $0x9, %esi
callq 0xdb20
testb $0x1, %al
jne 0x100e4
jmp 0x10137
movq -0x80(%rbp), %rdi
movl $0x9, %esi
callq 0xd670
movq -0x80(%rbp), %rdi
callq 0xfca0
movq -0x80(%rbp), %rdi
callq 0x10050
jmp 0x10137
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x10129
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3558
leaq -0x29(%rbp), %rdi
callq 0x3300
jmp 0x101e7
movl 0x1218f(%rip), %eax     # 0x222cc
decl %eax
movl %eax, 0x12187(%rip)     # 0x222cc
movl 0x12181(%rip), %eax     # 0x222cc
movl %eax, -0x90(%rbp)
movb 0x12171(%rip), %al      # 0x222c8
movb %al, -0x89(%rbp)
leaq -0x61(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x3510
movq -0x88(%rbp), %rdx
leaq 0x91f5(%rip), %rsi      # 0x19370
leaq -0x60(%rbp), %rdi
callq 0xb640
jmp 0x10186
movl -0x90(%rbp), %edi
movb -0x89(%rbp), %al
movsbl %al, %esi
leaq -0x60(%rbp), %rdx
callq 0x15550
jmp 0x101a0
leaq -0x60(%rbp), %rdi
callq 0x3558
leaq -0x61(%rbp), %rdi
callq 0x3300
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x101de
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3558
leaq -0x61(%rbp), %rdi
callq 0x3300
movq -0x38(%rbp), %rdi
callq 0x3500
// File: Blaze2305[P]Compiler-Design-2021-Assignment/src/Parser/Parser.cpp
// Function: Parser::parseExpA()
void Parser::parseExpA(){
	tabNum+=1;
	printParseEnters(tabNum,tabChar,"parseExpA");
	if(checkToken(Operator)){
		accept(Operator);
		parseExp();
		parseExpA();
	}
	tabNum-=1;
	printParseExits(tabNum,tabChar,"parseExpA");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movl 0x120bf(%rip), %eax     # 0x222cc
incl %eax
movl %eax, 0x120b7(%rip)     # 0x222cc
movl 0x120b1(%rip), %eax     # 0x222cc
movl %eax, -0x78(%rbp)
movb 0x120a4(%rip), %al      # 0x222c8
movb %al, -0x71(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x3510
movq -0x70(%rbp), %rdx
leaq 0x9145(%rip), %rsi      # 0x19384
leaq -0x28(%rbp), %rdi
callq 0xb640
jmp 0x1024a
movl -0x78(%rbp), %edi
movb -0x71(%rbp), %al
movsbl %al, %esi
leaq -0x28(%rbp), %rdx
callq 0x15530
jmp 0x1025e
leaq -0x28(%rbp), %rdi
callq 0x3558
leaq -0x29(%rbp), %rdi
callq 0x3300
movq -0x80(%rbp), %rdi
movl $0x3, %esi
callq 0xdb20
testb $0x1, %al
jne 0x10284
jmp 0x102d7
movq -0x80(%rbp), %rdi
movl $0x3, %esi
callq 0xd670
movq -0x80(%rbp), %rdi
callq 0xfaa0
movq -0x80(%rbp), %rdi
callq 0x101f0
jmp 0x102d7
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x102c9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3558
leaq -0x29(%rbp), %rdi
callq 0x3300
jmp 0x10387
movl 0x11fef(%rip), %eax     # 0x222cc
decl %eax
movl %eax, 0x11fe7(%rip)     # 0x222cc
movl 0x11fe1(%rip), %eax     # 0x222cc
movl %eax, -0x90(%rbp)
movb 0x11fd1(%rip), %al      # 0x222c8
movb %al, -0x89(%rbp)
leaq -0x61(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x3510
movq -0x88(%rbp), %rdx
leaq 0x9069(%rip), %rsi      # 0x19384
leaq -0x60(%rbp), %rdi
callq 0xb640
jmp 0x10326
movl -0x90(%rbp), %edi
movb -0x89(%rbp), %al
movsbl %al, %esi
leaq -0x60(%rbp), %rdx
callq 0x15550
jmp 0x10340
leaq -0x60(%rbp), %rdi
callq 0x3558
leaq -0x61(%rbp), %rdi
callq 0x3300
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x1037e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3558
leaq -0x61(%rbp), %rdi
callq 0x3300
movq -0x38(%rbp), %rdi
callq 0x3500
// File: Blaze2305[P]Compiler-Design-2021-Assignment/src/Parser/Parser.cpp
// Function: Parser::parseNumber()
void Parser::parseNumber(){
	tabNum+=1;
	printParseEnters(tabNum,tabChar,"parseNumber");
	accept(Number);
	tabNum-=1;
	printParseExits(tabNum,tabChar,"parseNumber");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x80(%rbp)
movl 0x11f1f(%rip), %eax     # 0x222cc
incl %eax
movl %eax, 0x11f17(%rip)     # 0x222cc
movl 0x11f11(%rip), %eax     # 0x222cc
movl %eax, -0x78(%rbp)
movb 0x11f04(%rip), %al      # 0x222c8
movb %al, -0x71(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x3510
movq -0x70(%rbp), %rdx
leaq 0x8faf(%rip), %rsi      # 0x1938e
leaq -0x28(%rbp), %rdi
callq 0xb640
jmp 0x103ea
movl -0x78(%rbp), %edi
movb -0x71(%rbp), %al
movsbl %al, %esi
leaq -0x28(%rbp), %rdx
callq 0x15530
jmp 0x103fe
leaq -0x28(%rbp), %rdi
callq 0x3558
leaq -0x29(%rbp), %rdi
callq 0x3300
movq -0x80(%rbp), %rdi
movl $0x1, %esi
callq 0xd670
movl 0x11ea8(%rip), %eax     # 0x222cc
decl %eax
movl %eax, 0x11ea0(%rip)     # 0x222cc
movl 0x11e9a(%rip), %eax     # 0x222cc
movl %eax, -0x90(%rbp)
movb 0x11e8a(%rip), %al      # 0x222c8
movb %al, -0x89(%rbp)
leaq -0x61(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x3510
movq -0x88(%rbp), %rdx
leaq 0x8f2c(%rip), %rsi      # 0x1938e
leaq -0x60(%rbp), %rdi
callq 0xb640
jmp 0x1046d
movl -0x90(%rbp), %edi
movb -0x89(%rbp), %al
movsbl %al, %esi
leaq -0x60(%rbp), %rdx
callq 0x15550
jmp 0x10487
leaq -0x60(%rbp), %rdi
callq 0x3558
leaq -0x61(%rbp), %rdi
callq 0x3300
addq $0x90, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x104c5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x3558
leaq -0x29(%rbp), %rdi
callq 0x3300
jmp 0x104fc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x104f3
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x3558
leaq -0x61(%rbp), %rdi
callq 0x3300
movq -0x38(%rbp), %rdi
callq 0x3500
nopw %cs:(%rax,%rax)
nop
// File: Blaze2305[P]Compiler-Design-2021-Assignment/src/Scanner/Scanner.cpp
// Function: Scanner::acceptChar()
void Scanner::acceptChar(){
	this->currentString += currentChar;
	char ch;
	if(inFile >> std::noskipws >> ch){
		this->currentChar = ch;
		// std::cout<<"CURRENT CHAR:  "<< this->currentChar << std::endl;
	}else{
		this->currentChar = '\u0000';
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movb (%rdi), %al
addq $0x8, %rdi
movsbl %al, %esi
callq 0x31b0
movq -0x18(%rbp), %rdi
addq $0x28, %rdi
leaq 0x87f(%rip), %rsi       # 0x122a0
callq 0x34b0
movq %rax, %rdi
leaq -0x9(%rbp), %rsi
callq 0x33d0
movq %rax, %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x33b0
testb $0x1, %al
jne 0x11a47
jmp 0x11a52
movq -0x18(%rbp), %rax
movb -0x9(%rbp), %cl
movb %cl, (%rax)
jmp 0x11a59
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nop
// File: Blaze2305[P]Compiler-Design-2021-Assignment/src/Scanner/Scanner.cpp
// Function: Scanner::discardChar()
void Scanner::discardChar(){
	char ch;
	if(inFile >> std::noskipws >> ch){
		this->currentChar = ch;
		// std::cout<<"CURRENT CHAR:  "<< this->currentChar << std::endl;
	}else{
		this->currentChar = '\u0000';
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x28, %rdi
leaq 0x821(%rip), %rsi       # 0x122a0
callq 0x34b0
movq %rax, %rdi
leaq -0x9(%rbp), %rsi
callq 0x33d0
movq %rax, %rdi
movq (%rdi), %rax
addq -0x18(%rax), %rdi
callq 0x33b0
testb $0x1, %al
jne 0x11aa5
jmp 0x11ab0
movq -0x18(%rbp), %rax
movb -0x9(%rbp), %cl
movb %cl, (%rax)
jmp 0x11ab7
movq -0x18(%rbp), %rax
movb $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: Blaze2305[P]Compiler-Design-2021-Assignment/src/Scanner/Scanner.cpp
// Function: Scanner::scanSeparator()
void Scanner::scanSeparator(){
	// skip whitespace \n \r \t
	if(this->currentChar == '\n'){
		this->line++;
	}
	discardChar();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movsbl (%rax), %eax
cmpl $0xa, %eax
jne 0x1218b
movl 0x1014e(%rip), %eax     # 0x222d0
addl $0x1, %eax
movl %eax, 0x10145(%rip)     # 0x222d0
movq -0x10(%rbp), %rdi
callq 0x11a60
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: Blaze2305[P]Compiler-Design-2021-Assignment/src/Scanner/Scanner.cpp
// Function: Scanner::getToken()
TokenRecord Scanner::getToken(){
	this->currentString = "";
	while(std::find(TO_SKIP.begin(), TO_SKIP.end(),this->currentChar)!=TO_SKIP.end()){
		scanSeparator();
	}
	this->currentKind = scanToken();
	return TokenRecord{
		this->currentKind,
		this->currentString,
		this->line
	};
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x28(%rbp)
movq %rdi, %rax
movq %rax, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x8, %rdi
leaq 0x725e(%rip), %rsi      # 0x1942c
callq 0x33f0
leaq 0x71f2(%rip), %rdi      # 0x193cc
callq 0x12470
movq %rax, -0x38(%rbp)
leaq 0x71e2(%rip), %rdi      # 0x193cc
callq 0x12490
movq -0x38(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq %rax, %rsi
callq 0x12420
movq %rax, -0x30(%rbp)
leaq 0x71c2(%rip), %rdi      # 0x193cc
callq 0x12490
movq %rax, %rcx
movq -0x30(%rbp), %rax
cmpq %rcx, %rax
je 0x12226
movq -0x18(%rbp), %rdi
callq 0x12160
jmp 0x121d3
movq -0x18(%rbp), %rdi
callq 0x11ac0
movq -0x18(%rbp), %rsi
movq -0x28(%rbp), %rdi
movl %eax, 0x4(%rsi)
movl 0x4(%rsi), %eax
movl %eax, (%rdi)
addq $0x8, %rdi
addq $0x8, %rsi
callq 0x3120
movq -0x28(%rbp), %rcx
movq -0x20(%rbp), %rax
movl 0x10076(%rip), %edx     # 0x222d0
movl %edx, 0x28(%rcx)
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: Blaze2305[P]Compiler-Design-2021-Assignment/src/SymTab/SymTab.cpp
// Function: SymbolTable::setSymbolValue(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void SymbolTable::setSymbolValue(std::string symbolName,std::string value){
	try{
		SymTabRow tableRow = SymbolTableMap.at(symbolName); 
		SymbolTableMap[symbolName].attribute = value;
	}catch(std::out_of_range err){
		std::ostringstream out;
		out << "Symbol " << symbolName << " does not exist.\n";
		throw std::runtime_error(out.str());
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x290, %rsp            # imm = 0x290
movq %rsi, -0x260(%rbp)
movq %rdx, -0x258(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x250(%rbp)
callq 0x13630
movq %rax, -0x248(%rbp)
jmp 0x12ece
movq -0x248(%rbp), %rsi
leaq -0x80(%rbp), %rdi
callq 0x136d0
jmp 0x12ee0
movq -0x260(%rbp), %rsi
movq -0x250(%rbp), %rdi
callq 0x13780
movq %rax, -0x268(%rbp)
jmp 0x12efc
movq -0x258(%rbp), %rsi
movq -0x268(%rbp), %rdi
addq $0x40, %rdi
callq 0x3040
jmp 0x12f15
leaq -0x80(%rbp), %rdi
callq 0x10c00
jmp 0x130ea
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x12f52
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x80(%rbp), %rdi
callq 0x10c00
movl -0x8c(%rbp), %eax
movl $0x1, %ecx
cmpl %ecx, %eax
jne 0x130f3
movq -0x88(%rbp), %rdi
movq %rdi, -0x270(%rbp)
callq 0x33a0
movq %rax, %rsi
leaq -0xa0(%rbp), %rdi
callq 0x12370
movq -0x270(%rbp), %rdi
callq 0x30f0
leaq -0x218(%rbp), %rdi
callq 0x33e0
jmp 0x12fa1
leaq 0x6428(%rip), %rsi      # 0x193d0
leaq -0x218(%rbp), %rdi
callq 0x3290
movq %rax, -0x278(%rbp)
jmp 0x12fbd
movq -0x260(%rbp), %rsi
movq -0x278(%rbp), %rdi
callq 0x3260
movq %rax, -0x280(%rbp)
jmp 0x12fd9
movq -0x280(%rbp), %rdi
leaq 0x6425(%rip), %rsi      # 0x1940c
callq 0x3290
jmp 0x12fee
movb $0x1, -0x239(%rbp)
movl $0x10, %edi
callq 0x3150
movq %rax, -0x288(%rbp)
leaq -0x238(%rbp), %rdi
leaq -0x218(%rbp), %rsi
callq 0x32c0
jmp 0x1301b
movq -0x288(%rbp), %rdi
leaq -0x238(%rbp), %rsi
callq 0x3470
jmp 0x13030
movq -0x288(%rbp), %rdi
movb $0x0, -0x239(%rbp)
movq 0xefab(%rip), %rsi      # 0x21ff0
movq 0xef74(%rip), %rdx      # 0x21fc0
callq 0x34d0
jmp 0x13107
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x130d5
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x130c9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
jmp 0x130b0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x88(%rbp)
movl %eax, -0x8c(%rbp)
leaq -0x238(%rbp), %rdi
callq 0x3558
testb $0x1, -0x239(%rbp)
jne 0x130bb
jmp 0x130c7
movq -0x288(%rbp), %rdi
callq 0x3200
jmp 0x130c9
leaq -0x218(%rbp), %rdi
callq 0x30c0
leaq -0xa0(%rbp), %rdi
callq 0x3420
callq 0x3480
jmp 0x130e8
jmp 0x130f3
addq $0x290, %rsp            # imm = 0x290
popq %rbp
retq
movq -0x88(%rbp), %rdi
callq 0x3500
movq %rax, %rdi
callq 0xbc80
nopw (%rax,%rax)
// File: Blaze2305[P]Compiler-Design-2021-Assignment/src/Utils/Utils.cpp
// Function: splitString(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char)
std::vector<std::string> splitString(std::string exp,char delim){
	std::vector<std::string> split;
	std::string temp = "";
	for(auto item : exp){
		if(item == delim){
			split.push_back(temp);
			temp = "";
		}
		temp += item;
	}

	return split;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x90, %rsp
movq %rsi, -0x90(%rbp)
movq %rdi, -0x88(%rbp)
movb %dl, %al
movq %rdi, %rcx
movq %rcx, -0x80(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movb $0x0, -0x12(%rbp)
callq 0x10550
leaq -0x39(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x3510
movq -0x78(%rbp), %rdx
leaq 0x442e(%rip), %rsi      # 0x1942c
leaq -0x38(%rbp), %rdi
callq 0xb640
jmp 0x15009
leaq -0x39(%rbp), %rdi
callq 0x3300
movq -0x90(%rbp), %rax
movq %rax, -0x58(%rbp)
movq -0x58(%rbp), %rdi
callq 0x3240
movq %rax, -0x60(%rbp)
movq -0x58(%rbp), %rdi
callq 0x3190
movq %rax, -0x68(%rbp)
leaq -0x60(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x16260
testb $0x1, %al
jne 0x1504d
jmp 0x150da
leaq -0x60(%rbp), %rdi
callq 0x162a0
movb (%rax), %al
movb %al, -0x69(%rbp)
movsbl -0x69(%rbp), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
jne 0x150bb
movq -0x88(%rbp), %rdi
leaq -0x38(%rbp), %rsi
callq 0x10760
jmp 0x15079
leaq 0x43ac(%rip), %rsi      # 0x1942c
leaq -0x38(%rbp), %rdi
callq 0x33f0
jmp 0x1508b
jmp 0x150bb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x39(%rbp), %rdi
callq 0x3300
jmp 0x15106
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3558
jmp 0x15106
movsbl -0x69(%rbp), %esi
leaq -0x38(%rbp), %rdi
callq 0x31b0
jmp 0x150ca
jmp 0x150cc
leaq -0x60(%rbp), %rdi
callq 0x162c0
jmp 0x15037
movb $0x1, -0x12(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3558
testb $0x1, -0x12(%rbp)
jne 0x150f9
movq -0x88(%rbp), %rdi
callq 0x10570
movq -0x80(%rbp), %rax
addq $0x90, %rsp
popq %rbp
retq
movq -0x88(%rbp), %rdi
callq 0x10570
movq -0x48(%rbp), %rdi
callq 0x3500
nopl (%rax,%rax)
// File: menhits[P]phplus/src/../h/Operator.h
// Function: OperatorData::OperatorData(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, OperatorData::InputTaken, bool)
OperatorData(string textIn, int precedenceIn, InputTaken inputIn, bool overloadableIn)
	{
		text=textIn;
		precedence=precedenceIn;
		input=inputIn;
		overloadable=overloadableIn;
	}

// Assembly:
subq $0x48, %rsp
movq %rsi, 0x10(%rsp)
movb %r8b, %al
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movl %ecx, 0x30(%rsp)
andb $0x1, %al
movb %al, 0x2f(%rsp)
movq 0x40(%rsp), %rdi
movq %rdi, 0x8(%rsp)
movq %rdi, %rax
movq %rax, (%rsp)
callq 0xb4e0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xb050
jmp 0xf8eb
movq (%rsp), %rax
movl 0x34(%rsp), %ecx
movl %ecx, 0x20(%rax)
movl 0x30(%rsp), %ecx
movl %ecx, 0x28(%rax)
movb 0x2f(%rsp), %cl
andb $0x1, %cl
movb %cl, 0x24(%rax)
addq $0x48, %rsp
retq
movq 0x8(%rsp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x20(%rsp)
movl %eax, 0x1c(%rsp)
callq 0xb6e8
movq 0x20(%rsp), %rdi
callq 0xb680
nop
// File: menhits[P]phplus/src/AstNode.cpp
// Function: AstNodeBase::copyToNode(AstNodeBase*, bool)
void AstNodeBase::copyToNode(AstNodeBase* other, bool copyCache)
{
	other->inLeftType=inLeftType;
	other->inRightType=inRightType;
	other->nameHint=nameHint;
	
	if (copyCache)
	{
		other->action=action;
		other->returnType=returnType;
		other->dynamic=dynamic;
		other->ns=ns;
		other->inputHasBeenSet=inputHasBeenSet;
	}
}

// Assembly:
subq $0x28, %rsp
movb %dl, %al
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
andb $0x1, %al
movb %al, 0x17(%rsp)
movq 0x20(%rsp), %rsi
movq %rsi, 0x8(%rsp)
addq $0x28, %rsi
movq 0x18(%rsp), %rdi
addq $0x28, %rdi
callq 0x1a4e0
movq 0x8(%rsp), %rsi
addq $0x38, %rsi
movq 0x18(%rsp), %rdi
addq $0x38, %rdi
callq 0x1a4e0
movq 0x8(%rsp), %rsi
addq $0x8, %rsi
movq 0x18(%rsp), %rdi
addq $0x8, %rdi
callq 0xb050
testb $0x1, 0x17(%rsp)
je 0x12953
movq 0x8(%rsp), %rsi
addq $0x48, %rsi
movq 0x18(%rsp), %rdi
addq $0x48, %rdi
callq 0x1a510
movq 0x8(%rsp), %rsi
addq $0x58, %rsi
movq 0x18(%rsp), %rdi
addq $0x58, %rdi
callq 0x1a4e0
movq 0x8(%rsp), %rsi
movb 0x68(%rsi), %cl
movq 0x18(%rsp), %rax
andb $0x1, %cl
movb %cl, 0x68(%rax)
addq $0x70, %rsi
movq 0x18(%rsp), %rdi
addq $0x70, %rdi
callq 0x1a540
movq 0x8(%rsp), %rax
movb 0x80(%rax), %cl
movq 0x18(%rsp), %rax
andb $0x1, %cl
movb %cl, 0x80(%rax)
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: menhits[P]phplus/src/AstNode.cpp
// Function: AstList::getString[abi:cxx11]()
string AstList::getString()
{
	vector<string> data;
	
	for (int i=0; i<int(nodes.size()); i++)
	{
		data.push_back(nodes[i]->getString());
	}
	
	return str::makeList(data);
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, 0x18(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq 0x78(%rsp), %rax
movq %rax, 0x20(%rsp)
leaq 0x60(%rsp), %rdi
callq 0x1a570
movl $0x0, 0x5c(%rsp)
movq 0x20(%rsp), %rdi
movl 0x5c(%rsp), %eax
movl %eax, 0xc(%rsp)
addq $0x88, %rdi
callq 0x1a580
movq %rax, %rcx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0x12a4b
movq 0x20(%rsp), %rdi
addq $0x88, %rdi
movslq 0x5c(%rsp), %rsi
callq 0x1a5d0
movq %rax, %rdi
callq 0x1a5f0
movq %rax, %rsi
movq (%rsi), %rax
movq 0x18(%rax), %rax
leaq 0x38(%rsp), %rdi
callq *%rax
jmp 0x129f6
leaq 0x60(%rsp), %rdi
leaq 0x38(%rsp), %rsi
callq 0x1a5a0
jmp 0x12a07
leaq 0x38(%rsp), %rdi
callq 0xb6e8
movl 0x5c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x5c(%rsp)
jmp 0x1299d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
jmp 0x12a73
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x30(%rsp)
movl %eax, 0x2c(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xb6e8
jmp 0x12a73
movq 0x10(%rsp), %rdi
leaq 0x60(%rsp), %rsi
callq 0xca210
jmp 0x12a5c
leaq 0x60(%rsp), %rdi
callq 0x1a600
movq 0x18(%rsp), %rax
addq $0x88, %rsp
retq
leaq 0x60(%rsp), %rdi
callq 0x1a600
movq 0x30(%rsp), %rdi
callq 0xb680
nopw (%rax,%rax)
// File: menhits[P]phplus/src/AstNode.cpp
// Function: AstConstExpression::getString[abi:cxx11]()
string AstConstExpression::getString()
{
	string centerStr=center->getString();
	
	string rightStr;
	if (!rightIn->isVoid())
	{
		rightStr=rightIn->getString();
	}
	
	return str::makeRootUpBinaryTree(centerStr, "", "const", "", rightStr);
}

// Assembly:
subq $0x128, %rsp            # imm = 0x128
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x20(%rsp)
movq %rdi, 0x120(%rsp)
movq %rsi, 0x118(%rsp)
movq 0x118(%rsp), %rdi
movq %rdi, 0x28(%rsp)
addq $0x88, %rdi
callq 0x1bb60
movq %rax, %rsi
movq (%rsi), %rax
movq 0x18(%rax), %rax
leaq 0xf8(%rsp), %rdi
callq *%rax
leaq 0xd8(%rsp), %rdi
callq 0xb4e0
movq 0x28(%rsp), %rdi
addq $0x90, %rdi
callq 0x1a5f0
movq %rax, %rdi
movq (%rdi), %rax
movq (%rax), %rax
callq *%rax
movb %al, 0x36(%rsp)
jmp 0x15200
movb 0x36(%rsp), %al
testb $0x1, %al
jne 0x1526e
jmp 0x1520a
movq 0x28(%rsp), %rdi
addq $0x90, %rdi
callq 0x1a5f0
movq %rax, %rsi
movq (%rsi), %rax
movq 0x18(%rax), %rax
leaq 0xa8(%rsp), %rdi
callq *%rax
jmp 0x15231
leaq 0xd8(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
callq 0xb450
leaq 0xa8(%rsp), %rdi
callq 0xb6e8
jmp 0x1526e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd0(%rsp)
movl %eax, 0xcc(%rsp)
jmp 0x15416
leaq 0x87(%rsp), %rdi
movq %rdi, 0x10(%rsp)
callq 0xb690
movq 0x10(%rsp), %rdx
leaq 0xbc793(%rip), %rsi     # 0xd1a1f
leaq 0x88(%rsp), %rdi
callq 0xb4c0
jmp 0x1529b
leaq 0x5f(%rsp), %rdi
movq %rdi, 0x8(%rsp)
callq 0xb690
movq 0x8(%rsp), %rdx
leaq 0xbbf1b(%rip), %rsi     # 0xd11d1
leaq 0x60(%rsp), %rdi
callq 0xb4c0
jmp 0x152c2
leaq 0x37(%rsp), %rdi
movq %rdi, (%rsp)
callq 0xb690
movq (%rsp), %rdx
leaq 0xbc744(%rip), %rsi     # 0xd1a1f
leaq 0x38(%rsp), %rdi
callq 0xb4c0
jmp 0x152e7
movq 0x18(%rsp), %rdi
leaq 0xf8(%rsp), %rsi
leaq 0x88(%rsp), %rdx
leaq 0x60(%rsp), %rcx
leaq 0x38(%rsp), %r8
leaq 0xd8(%rsp), %r9
callq 0xcb290
jmp 0x15315
leaq 0x38(%rsp), %rdi
callq 0xb6e8
leaq 0x37(%rsp), %rdi
callq 0xb3f0
leaq 0x60(%rsp), %rdi
callq 0xb6e8
leaq 0x5f(%rsp), %rdi
callq 0xb3f0
leaq 0x88(%rsp), %rdi
callq 0xb6e8
leaq 0x87(%rsp), %rdi
callq 0xb3f0
leaq 0xd8(%rsp), %rdi
callq 0xb6e8
leaq 0xf8(%rsp), %rdi
callq 0xb6e8
movq 0x20(%rsp), %rax
addq $0x128, %rsp            # imm = 0x128
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd0(%rsp)
movl %eax, 0xcc(%rsp)
jmp 0x15409
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd0(%rsp)
movl %eax, 0xcc(%rsp)
jmp 0x153f2
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd0(%rsp)
movl %eax, 0xcc(%rsp)
jmp 0x153de
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0xd0(%rsp)
movl %eax, 0xcc(%rsp)
leaq 0x38(%rsp), %rdi
callq 0xb6e8
leaq 0x37(%rsp), %rdi
callq 0xb3f0
leaq 0x60(%rsp), %rdi
callq 0xb6e8
leaq 0x5f(%rsp), %rdi
callq 0xb3f0
leaq 0x88(%rsp), %rdi
callq 0xb6e8
leaq 0x87(%rsp), %rdi
callq 0xb3f0
leaq 0xd8(%rsp), %rdi
callq 0xb6e8
leaq 0xf8(%rsp), %rdi
callq 0xb6e8
movq 0xd0(%rsp), %rdi
callq 0xb680
nopl (%rax)
// File: menhits[P]phplus/src/AstNode.cpp
// Function: AstTuple::resolveAction()
void AstTuple::resolveAction()
{
	vector<Action> actions;
	
	for (int i=0; i<int(nodes.size()); i++)
	{
		nodes[i]->setInput(ns, dynamic, Void, Void);
		actions.push_back(nodes[i]->getAction());
	}
	
	action=makeTupleAction(actions);
}

// Assembly:
subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movq 0xc0(%rsp), %rax
movq %rax, 0x38(%rsp)
leaq 0xa8(%rsp), %rdi
callq 0x1aa90
movl $0x0, 0xa4(%rsp)
movq 0x38(%rsp), %rdi
movl 0xa4(%rsp), %eax
movl %eax, 0x34(%rsp)
addq $0x88, %rdi
callq 0x1a580
movq %rax, %rcx
movl 0x34(%rsp), %eax
cmpl %ecx, %eax
jge 0x19b75
movq 0x38(%rsp), %rdi
addq $0x88, %rdi
movslq 0xa4(%rsp), %rsi
callq 0x1a5d0
movq %rax, %rdi
callq 0x1a5f0
movq 0x38(%rsp), %rsi
movq %rax, 0x10(%rsp)
addq $0x70, %rsi
leaq 0x90(%rsp), %rdi
movq %rdi, 0x18(%rsp)
callq 0x1a8f0
movq 0x38(%rsp), %rax
movzbl 0x68(%rax), %eax
movl %eax, 0xc(%rsp)
leaq 0xfea64(%rip), %rsi     # 0x1184a8
movq %rsi, (%rsp)
leaq 0x80(%rsp), %rdi
movq %rdi, 0x20(%rsp)
callq 0x1a920
movq (%rsp), %rsi
leaq 0x70(%rsp), %rdi
movq %rdi, 0x28(%rsp)
callq 0x1a920
movl 0xc(%rsp), %edx
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rcx
movq 0x28(%rsp), %r8
andl $0x1, %edx
callq 0x1a6f0
jmp 0x19a8f
leaq 0x70(%rsp), %rdi
callq 0x1a950
leaq 0x80(%rsp), %rdi
callq 0x1a950
leaq 0x90(%rsp), %rdi
callq 0x1a6e0
movq 0x38(%rsp), %rdi
addq $0x88, %rdi
movslq 0xa4(%rsp), %rsi
callq 0x1a5d0
movq %rax, %rdi
callq 0x1a5f0
movq %rax, %rsi
leaq 0x50(%rsp), %rdi
callq 0x1aaa0
jmp 0x19ae3
leaq 0xa8(%rsp), %rdi
leaq 0x50(%rsp), %rsi
callq 0x1be60
jmp 0x19af7
leaq 0x50(%rsp), %rdi
callq 0x1acc0
movl 0xa4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xa4(%rsp)
jmp 0x199c4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x70(%rsp), %rdi
callq 0x1a950
leaq 0x80(%rsp), %rdi
callq 0x1a950
leaq 0x90(%rsp), %rdi
callq 0x1a6e0
jmp 0x19bbb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
jmp 0x19bbb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x68(%rsp)
movl %eax, 0x64(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x1acc0
jmp 0x19bbb
leaq 0x40(%rsp), %rdi
leaq 0xa8(%rsp), %rsi
callq 0xbfe90
jmp 0x19b89
movq 0x38(%rsp), %rdi
addq $0x48, %rdi
leaq 0x40(%rsp), %rsi
callq 0x1ac90
leaq 0x40(%rsp), %rdi
callq 0x1acc0
leaq 0xa8(%rsp), %rdi
callq 0x1adb0
addq $0xc8, %rsp
retq
leaq 0xa8(%rsp), %rdi
callq 0x1adb0
movq 0x68(%rsp), %rdi
callq 0xb680
nopw %cs:(%rax,%rax)
// File: menhits[P]phplus/src/AstNode.cpp
// Function: AstTupleType::getString[abi:cxx11]()
string AstTupleType::getString()
{
	string out;
	
	out+="AstTupleType{";
	
	for (int i=0; i<int(subTypes.size()); i++)
	{
		auto type=&subTypes[i];
		
		if (type->name)
		{
			out+=type->name->getText()+": ";
		}
		
		out+=type->type->getString();
		
		if (i<int(subTypes.size())-1)
		{
			out+=", ";
		}
	}
	
	out+="}";
	
	return out;
}

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0x20(%rsp)
movq %rdi, %rax
movq %rax, 0x10(%rsp)
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq 0xa8(%rsp), %rax
movq %rax, 0x18(%rsp)
movb $0x0, 0xa7(%rsp)
callq 0xb4e0
movq 0x20(%rsp), %rdi
leaq 0xb768c(%rip), %rsi     # 0xd14c6
callq 0xb360
jmp 0x19e41
movl $0x0, 0x90(%rsp)
movq 0x18(%rsp), %rdi
movl 0x90(%rsp), %eax
movl %eax, 0xc(%rsp)
addq $0x88, %rdi
callq 0x1c010
movq %rax, %rcx
movl 0xc(%rsp), %eax
cmpl %ecx, %eax
jge 0x1a01b
movq 0x18(%rsp), %rdi
addq $0x88, %rdi
movslq 0x90(%rsp), %rsi
callq 0x1c030
movq %rax, 0x88(%rsp)
movq 0x88(%rsp), %rdi
callq 0x1c050
testb $0x1, %al
jne 0x19eae
jmp 0x19f65
movq 0x88(%rsp), %rdi
callq 0x1bb70
movq %rax, %rsi
leaq 0x48(%rsp), %rdi
callq 0x1bb80
jmp 0x19eca
leaq 0xbd603(%rip), %rdx     # 0xd74d4
leaq 0x68(%rsp), %rdi
leaq 0x48(%rsp), %rsi
callq 0xfa60
jmp 0x19ee2
movq 0x20(%rsp), %rdi
leaq 0x68(%rsp), %rsi
callq 0xb470
jmp 0x19ef3
leaq 0x68(%rsp), %rdi
callq 0xb6e8
leaq 0x48(%rsp), %rdi
callq 0xb6e8
jmp 0x19f65
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
jmp 0x1a057
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
jmp 0x19f56
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
leaq 0x68(%rsp), %rdi
callq 0xb6e8
leaq 0x48(%rsp), %rdi
callq 0xb6e8
jmp 0x1a057
movq 0x88(%rsp), %rdi
addq $0x10, %rdi
callq 0x1c070
movq %rax, %rsi
movq (%rsi), %rax
movq 0x18(%rax), %rax
leaq 0x28(%rsp), %rdi
callq *%rax
jmp 0x19f89
movq 0x20(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0xb470
jmp 0x19f9a
leaq 0x28(%rsp), %rdi
callq 0xb6e8
movq 0x18(%rsp), %rdi
movl 0x90(%rsp), %eax
movl %eax, 0x8(%rsp)
addq $0x88, %rdi
callq 0x1c010
movq %rax, %rcx
movl 0x8(%rsp), %eax
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x1a003
movq 0x20(%rsp), %rdi
leaq 0xbb710(%rip), %rsi     # 0xd56ea
callq 0xb360
jmp 0x19fe1
jmp 0x1a003
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x98(%rsp)
movl %eax, 0x94(%rsp)
leaq 0x28(%rsp), %rdi
callq 0xb6e8
jmp 0x1a057
jmp 0x1a005
movl 0x90(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x90(%rsp)
jmp 0x19e4c
movq 0x20(%rsp), %rdi
leaq 0xbb19a(%rip), %rsi     # 0xd51c1
callq 0xb360
jmp 0x1a02e
movb $0x1, 0xa7(%rsp)
testb $0x1, 0xa7(%rsp)
jne 0x1a04a
movq 0x20(%rsp), %rdi
callq 0xb6e8
movq 0x10(%rsp), %rax
addq $0xb8, %rsp
retq
movq 0x20(%rsp), %rdi
callq 0xb6e8
movq 0x98(%rsp), %rdi
callq 0xb680
nop
// File: menhits[P]phplus/src/../h/AstNode.h
// Function: AstNodeBase::setInput(std::shared_ptr<NamespaceData>, bool, std::shared_ptr<TypeBase>, std::shared_ptr<TypeBase>)
void setInput(Namespace nsIn, bool dynamicIn, Type left, Type right)
	{
		if (inputHasBeenSet)
		{
			throw PhplusError("tried to set input on an AST node '"+getString()+"' more then once", INTERNAL_ERROR, getToken());
		}
		
		inputHasBeenSet=true;
		
		ns=nsIn;
		dynamic=dynamicIn;
		inLeftType=left;
		inRightType=right;
	}

// Assembly:
subq $0xd8, %rsp
movq %r8, 0x8(%rsp)
movq %rcx, 0x10(%rsp)
movq %rsi, 0x18(%rsp)
movb %dl, %al
movq %rdi, 0xd0(%rsp)
movq %rsi, 0xc8(%rsp)
andb $0x1, %al
movb %al, 0xc7(%rsp)
movq %rcx, 0xb8(%rsp)
movq %r8, 0xb0(%rsp)
movq 0xd0(%rsp), %rax
movq %rax, 0x20(%rsp)
testb $0x1, 0x80(%rax)
je 0x1a886
movb $0x1, 0x2f(%rsp)
movl $0x38, %edi
callq 0xb1f0
movq 0x20(%rsp), %rsi
movq %rax, (%rsp)
movq (%rsi), %rax
movq 0x18(%rax), %rax
leaq 0x50(%rsp), %rdi
callq *%rax
jmp 0x1a773
leaq 0xb6d5a(%rip), %rsi     # 0xd14d4
leaq 0x70(%rsp), %rdi
leaq 0x50(%rsp), %rdx
callq 0x1bcf0
jmp 0x1a78b
leaq 0xb6d66(%rip), %rdx     # 0xd14f8
leaq 0x90(%rsp), %rdi
leaq 0x70(%rsp), %rsi
callq 0xfa60
jmp 0x1a7a6
movq 0x20(%rsp), %rsi
movq (%rsi), %rax
movq 0x38(%rax), %rax
leaq 0x30(%rsp), %rdi
callq *%rax
jmp 0x1a7bb
movq (%rsp), %rdi
leaq 0x90(%rsp), %rsi
movl $0x3, %edx
leaq 0x30(%rsp), %rcx
callq 0x35600
jmp 0x1a7d8
movq (%rsp), %rdi
movb $0x0, 0x2f(%rsp)
leaq 0xfade0(%rip), %rsi     # 0x1155c8
leaq -0x17f(%rip), %rdx      # 0x1a670
callq 0xb640
jmp 0x1a8e4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0x1a872
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0x1a868
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0x1a85e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
jmp 0x1a851
movq %rax, %rcx
movl %edx, %eax
movq %rcx, 0x48(%rsp)
movl %eax, 0x44(%rsp)
leaq 0x30(%rsp), %rdi
callq 0xfc00
leaq 0x90(%rsp), %rdi
callq 0xb6e8
leaq 0x70(%rsp), %rdi
callq 0xb6e8
leaq 0x50(%rsp), %rdi
callq 0xb6e8
testb $0x1, 0x2f(%rsp)
jne 0x1a87b
jmp 0x1a884
movq (%rsp), %rdi
callq 0xb2d0
jmp 0x1a8da
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
movb $0x1, 0x80(%rdi)
addq $0x70, %rdi
callq 0x1a540
movq 0x10(%rsp), %rsi
movq 0x20(%rsp), %rdi
movb 0xc7(%rsp), %al
andb $0x1, %al
movb %al, 0x68(%rdi)
addq $0x28, %rdi
callq 0x1a4e0
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
addq $0x38, %rdi
callq 0x1a4e0
addq $0xd8, %rsp
retq
movq 0x48(%rsp), %rdi
callq 0xb680
nopw %cs:(%rax,%rax)
nop