LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/Blaze2305[P]Compiler-Design-2021-Assignment/src/Models/Structs.cpp
// Function: operator<<(std::ostream&, TokenRecord const&)
std::ostream& operator<< (std::ostream& out, const TokenRecord& obj){
	out<<"\n------------------------------------------------------------------------------\n";
	out<<"Token Type --> "<<TOKEN_ENUM_TYPE_NAMES[obj.tokenType]<<std::endl;
	out<<"String Value --> "<<obj.Value<<std::endl;
	out<<"Line Number --> "<<obj.lineNumber<<std::endl;
	out<<"\n------------------------------------------------------------------------------\n";
	return out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x462a(%rip), %r14      # 0xa160
movq %r14, %rsi
callq 0x21d0
leaq 0x468e(%rip), %rsi      # 0xa1d3
movq %rbx, %rdi
callq 0x21d0
movl (%r15), %ecx
shlq $0x5, %rcx
leaq 0x9de5(%rip), %rsi      # 0xf940
addq %rcx, %rsi
movq %rax, %rdi
callq 0x21c0
movq %rax, %rdi
callq 0x2110
leaq 0x466e(%rip), %rsi      # 0xa1e3
movq %rbx, %rdi
callq 0x21d0
leaq 0x8(%r15), %rsi
movq %rax, %rdi
callq 0x21c0
movq %rax, %rdi
callq 0x2110
leaq 0x462a(%rip), %rsi      # 0xa1c2
movq %rbx, %rdi
callq 0x21d0
movl 0x28(%r15), %esi
movq %rax, %rdi
callq 0x2360
movq %rax, %rdi
callq 0x2110
movq %rbx, %rdi
movq %r14, %rsi
callq 0x21d0
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/Blaze2305[P]Compiler-Design-2021-Assignment/src/Parser/Parser.cpp
// Function: Parser::parse()
void Parser::parse(){
	currentToken = scanner->getToken();
	parseProgram();
	if(currentToken.tokenType != EOT){
		std::ostringstream out ;
		out << "Syntax error on line ";
		out << currentToken.lineNumber;
		out << " Redundant chars at the end";
		throw  std::runtime_error(out.str());
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x198, %rsp            # imm = 0x198
movq %rdi, %rbx
movq 0x30(%rdi), %rsi
leaq -0x1b0(%rbp), %r14
movq %r14, %rdi
callq 0x8054
movq %rbx, %rdi
movq %r14, %rsi
callq 0x773a
leaq -0x1a8(%rbp), %rdi
callq 0x23b8
movq %rbx, %rdi
callq 0x6106
cmpl $0x8, (%rbx)
jne 0x6052
addq $0x198, %rsp            # imm = 0x198
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
callq 0x2280
leaq 0x41ab(%rip), %rsi      # 0xa20c
movq %r14, %rdi
callq 0x21d0
movl 0x28(%rbx), %esi
leaq -0x1b0(%rbp), %rdi
callq 0x2360
leaq 0x41fe(%rip), %rsi      # 0xa27d
leaq -0x1b0(%rbp), %rdi
callq 0x21d0
pushq $0x10
popq %rdi
callq 0x2120
movq %rax, %rbx
leaq -0x1a8(%rbp), %rsi
leaq -0x38(%rbp), %rdi
callq 0x2300
movb $0x1, %r15b
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x2310
xorl %r15d, %r15d
movq 0x8f31(%rip), %rsi      # 0xeff0
movq 0x8f02(%rip), %rdx      # 0xefc8
movq %rbx, %rdi
callq 0x2350
movq %rax, %r14
leaq -0x38(%rbp), %rdi
callq 0x23b8
testb %r15b, %r15b
jne 0x60e4
jmp 0x60f1
movq %rax, %r14
movq %rbx, %rdi
callq 0x2170
jmp 0x60f1
movq %rax, %r14
leaq -0x1b0(%rbp), %rdi
callq 0x20a0
movq %r14, %rdi
callq 0x2370
nop
// File: /workspace/github_cpp_makefile_star2_O2/Blaze2305[P]Compiler-Design-2021-Assignment/src/Parser/Parser.cpp
// Function: Parser::parseProgram()
void Parser::parseProgram(){
	tabNum+=1;
	printParseEnters(tabNum,tabChar,"parseProgram");
	accept(Global);
	if(checkToken(Def)){
		parseDeclList();
	}
	identifierCheckFlag = true;
	parseStmtList();
	accept(End);
	tabNum-=1;
	printParseExits(tabNum,tabChar,"parseProgram");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movl 0x90df(%rip), %r14d     # 0xf1fc
incl %r14d
movl %r14d, 0x90d5(%rip)     # 0xf1fc
movb 0x90ca(%rip), %r15b     # 0xf1f8
leaq 0x4164(%rip), %rsi      # 0xa299
leaq -0x60(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x530a
movsbl %r15b, %esi
leaq -0x60(%rbp), %rdx
movl %r14d, %edi
callq 0x94b6
leaq -0x60(%rbp), %rdi
callq 0x23b8
pushq $0xa
popq %rsi
movq %rbx, %rdi
callq 0x5d06
cmpl $0xc, (%rbx)
jne 0x6173
movq %rbx, %rdi
callq 0x61fa
movb $0x1, 0x6c(%rbx)
movq %rbx, %rdi
callq 0x62d6
pushq $0xb
popq %rsi
movq %rbx, %rdi
callq 0x5d06
movl 0x906c(%rip), %ebx      # 0xf1fc
decl %ebx
movl %ebx, 0x9064(%rip)      # 0xf1fc
movb 0x9059(%rip), %r14b     # 0xf1f8
leaq 0x40f3(%rip), %rsi      # 0xa299
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x530a
movsbl %r14b, %esi
leaq -0x40(%rbp), %rdx
movl %ebx, %edi
callq 0x94bc
leaq -0x40(%rbp), %rdi
callq 0x23b8
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
jmp 0x61e8
jmp 0x61ef
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x23b8
jmp 0x61f2
movq %rax, %rbx
movq %rbx, %rdi
callq 0x2370
// File: /workspace/github_cpp_makefile_star2_O2/Blaze2305[P]Compiler-Design-2021-Assignment/src/Parser/Parser.cpp
// Function: Parser::parseDeclList()
void Parser::parseDeclList(){
	tabNum+=1;
	printParseEnters(tabNum,tabChar,"parseDeclList");
	parseDecl();
	while(checkToken(Def)){
		parseDeclList();
	}
	tabNum-=1;
	printParseExits(tabNum,tabChar,"parseDeclList");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movl 0x8feb(%rip), %r14d     # 0xf1fc
incl %r14d
movl %r14d, 0x8fe1(%rip)     # 0xf1fc
movb 0x8fd6(%rip), %r15b     # 0xf1f8
leaq 0x407d(%rip), %rsi      # 0xa2a6
leaq -0x60(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x530a
movsbl %r15b, %esi
leaq -0x60(%rbp), %rdx
movl %r14d, %edi
callq 0x94b6
leaq -0x60(%rbp), %rdi
callq 0x23b8
movq %rbx, %rdi
callq 0x63b6
cmpl $0xc, (%rbx)
jne 0x6266
movq %rbx, %rdi
callq 0x61fa
jmp 0x6257
movl 0x8f90(%rip), %ebx      # 0xf1fc
decl %ebx
movl %ebx, 0x8f88(%rip)      # 0xf1fc
movb 0x8f7d(%rip), %r14b     # 0xf1f8
leaq 0x4024(%rip), %rsi      # 0xa2a6
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x530a
movsbl %r14b, %esi
leaq -0x40(%rbp), %rdx
movl %ebx, %edi
callq 0x94bc
leaq -0x40(%rbp), %rdi
callq 0x23b8
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
jmp 0x62c4
jmp 0x62cb
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x23b8
jmp 0x62ce
movq %rax, %rbx
movq %rbx, %rdi
callq 0x2370
// File: /workspace/github_cpp_makefile_star2_O2/Blaze2305[P]Compiler-Design-2021-Assignment/src/Parser/Parser.cpp
// Function: Parser::parseStmtList()
void Parser::parseStmtList(){
	tabNum+=1;
	printParseEnters(tabNum,tabChar,"parseStmtList");
	parseStmt();
	accept(SemiColon);
	parseStmtListA();
	tabNum-=1;
	printParseExits(tabNum,tabChar,"parseStmtList");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movl 0x8f0f(%rip), %r14d     # 0xf1fc
incl %r14d
movl %r14d, 0x8f05(%rip)     # 0xf1fc
movb 0x8efa(%rip), %r15b     # 0xf1f8
leaq 0x3ff6(%rip), %rsi      # 0xa2fb
leaq -0x60(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x530a
movsbl %r15b, %esi
leaq -0x60(%rbp), %rdx
movl %r14d, %edi
callq 0x94b6
leaq -0x60(%rbp), %rdi
callq 0x23b8
movq %rbx, %rdi
callq 0x6a20
pushq $0xf
popq %rsi
movq %rbx, %rdi
callq 0x5d06
movq %rbx, %rdi
callq 0x6be0
movl 0x8eb0(%rip), %ebx      # 0xf1fc
decl %ebx
movl %ebx, 0x8ea8(%rip)      # 0xf1fc
movb 0x8e9d(%rip), %r14b     # 0xf1f8
leaq 0x3f99(%rip), %rsi      # 0xa2fb
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x530a
movsbl %r14b, %esi
leaq -0x40(%rbp), %rdx
movl %ebx, %edi
callq 0x94bc
leaq -0x40(%rbp), %rdi
callq 0x23b8
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
jmp 0x63a4
jmp 0x63ab
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x23b8
jmp 0x63ae
movq %rax, %rbx
movq %rbx, %rdi
callq 0x2370
// File: /workspace/github_cpp_makefile_star2_O2/Blaze2305[P]Compiler-Design-2021-Assignment/src/Parser/Parser.cpp
// Function: Parser::parseDecl()
void Parser::parseDecl(){
	tabNum+=1;
	printParseEnters(tabNum,tabChar,"parseDecl");
	accept(Def);
	parseTypeList();
	accept(End);
	tabNum-=1;
	printParseExits(tabNum,tabChar,"parseDecl");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movl 0x8e2f(%rip), %r14d     # 0xf1fc
incl %r14d
movl %r14d, 0x8e25(%rip)     # 0xf1fc
movb 0x8e1a(%rip), %r15b     # 0xf1f8
leaq 0x3ecf(%rip), %rsi      # 0xa2b4
leaq -0x60(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x530a
movsbl %r15b, %esi
leaq -0x60(%rbp), %rdx
movl %r14d, %edi
callq 0x94b6
leaq -0x60(%rbp), %rdi
callq 0x23b8
pushq $0xc
popq %rsi
movq %rbx, %rdi
callq 0x5d06
movq %rbx, %rdi
callq 0x649a
pushq $0xb
popq %rsi
movq %rbx, %rdi
callq 0x5d06
movl 0x8dcd(%rip), %ebx      # 0xf1fc
decl %ebx
movl %ebx, 0x8dc5(%rip)      # 0xf1fc
movb 0x8dba(%rip), %r14b     # 0xf1f8
leaq 0x3e6f(%rip), %rsi      # 0xa2b4
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x530a
movsbl %r14b, %esi
leaq -0x40(%rbp), %rdx
movl %ebx, %edi
callq 0x94bc
leaq -0x40(%rbp), %rdi
callq 0x23b8
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
jmp 0x6487
jmp 0x648e
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x23b8
jmp 0x6491
movq %rax, %rbx
movq %rbx, %rdi
callq 0x2370
nop
// File: /workspace/github_cpp_makefile_star2_O2/Blaze2305[P]Compiler-Design-2021-Assignment/src/Parser/Parser.cpp
// Function: Parser::parseTypeList()
void Parser::parseTypeList(){
	tabNum+=1;
	printParseEnters(tabNum,tabChar,"parseTypeList");
	parseVarList();
	accept(Colon);
	parseType();
	accept(SemiColon);
	parseTypeListA();
	tabNum-=1;
	printParseExits(tabNum,tabChar,"parseTypeList");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movl 0x8d4b(%rip), %r14d     # 0xf1fc
incl %r14d
movl %r14d, 0x8d41(%rip)     # 0xf1fc
movb 0x8d36(%rip), %r15b     # 0xf1f8
leaq 0x3df5(%rip), %rsi      # 0xa2be
leaq -0x60(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x530a
movsbl %r15b, %esi
leaq -0x60(%rbp), %rdx
movl %r14d, %edi
callq 0x94b6
leaq -0x60(%rbp), %rdi
callq 0x23b8
movq %rbx, %rdi
callq 0x658e
pushq $0xe
popq %rsi
movq %rbx, %rdi
callq 0x5d06
movq %rbx, %rdi
callq 0x6678
pushq $0xf
popq %rsi
movq %rbx, %rdi
callq 0x5d06
movq %rbx, %rdi
callq 0x684c
movl 0x8cd9(%rip), %ebx      # 0xf1fc
decl %ebx
movl %ebx, 0x8cd1(%rip)      # 0xf1fc
movb 0x8cc6(%rip), %r14b     # 0xf1f8
leaq 0x3d85(%rip), %rsi      # 0xa2be
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x530a
movsbl %r14b, %esi
leaq -0x40(%rbp), %rdx
movl %ebx, %edi
callq 0x94bc
leaq -0x40(%rbp), %rdi
callq 0x23b8
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
jmp 0x657b
jmp 0x6582
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x23b8
jmp 0x6585
movq %rax, %rbx
movq %rbx, %rdi
callq 0x2370
nop
// File: /workspace/github_cpp_makefile_star2_O2/Blaze2305[P]Compiler-Design-2021-Assignment/src/Parser/Parser.cpp
// Function: Parser::parseVarList()
void Parser::parseVarList(){
	tabNum+=1;
	printParseEnters(tabNum,tabChar,"parseVarList");
	if(checkToken(Identifier)){
		parseVar();
		if(checkToken(Comma)){
			accept(Comma);
			parseVarList();
		}
	}
	tabNum-=1;
	printParseExits(tabNum,tabChar,"parseVarList");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movl 0x8c57(%rip), %r14d     # 0xf1fc
incl %r14d
movl %r14d, 0x8c4d(%rip)     # 0xf1fc
movb 0x8c42(%rip), %r15b     # 0xf1f8
leaq 0x3d28(%rip), %rsi      # 0xa2e5
leaq -0x60(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x530a
movsbl %r15b, %esi
leaq -0x60(%rbp), %rdx
movl %r14d, %edi
callq 0x94b6
leaq -0x60(%rbp), %rdi
callq 0x23b8
cmpl $0x0, (%rbx)
jne 0x6608
movq %rbx, %rdi
callq 0x6944
cmpl $0x15, (%rbx)
jne 0x6608
pushq $0x15
popq %rsi
movq %rbx, %rdi
callq 0x5d06
movq %rbx, %rdi
callq 0x658e
movl 0x8bee(%rip), %ebx      # 0xf1fc
decl %ebx
movl %ebx, 0x8be6(%rip)      # 0xf1fc
movb 0x8bdb(%rip), %r14b     # 0xf1f8
leaq 0x3cc1(%rip), %rsi      # 0xa2e5
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x530a
movsbl %r14b, %esi
leaq -0x40(%rbp), %rdx
movl %ebx, %edi
callq 0x94bc
leaq -0x40(%rbp), %rdi
callq 0x23b8
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
jmp 0x6666
jmp 0x666d
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x23b8
jmp 0x6670
movq %rax, %rbx
movq %rbx, %rdi
callq 0x2370
// File: /workspace/github_cpp_makefile_star2_O2/Blaze2305[P]Compiler-Design-2021-Assignment/src/Parser/Parser.cpp
// Function: Parser::parseType()
void Parser::parseType(){
	tabNum+=1;
	printParseEnters(tabNum,tabChar,"parseType");
	std::string tempType = this->currentToken.Value;
	int tempLineNum = this->currentToken.lineNumber;
	accept(Type);
	for(std::string symbol : this->symbolNamesList){
		this->symtab.addSymbolToTable(symbol,tempLineNum,tempType);
	}
	this->symbolNamesList.clear();
	tabNum-=1;
	printParseExits(tabNum,tabChar,"parseType");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xd8, %rsp
movq %rdi, %r15
movl 0x8b67(%rip), %ebx      # 0xf1fc
incl %ebx
movl %ebx, 0x8b5f(%rip)      # 0xf1fc
movb 0x8b54(%rip), %r14b     # 0xf1f8
leaq 0x3c30(%rip), %rsi      # 0xa2db
leaq -0xa0(%rbp), %rdi
leaq -0x60(%rbp), %rdx
callq 0x530a
movsbl %r14b, %esi
leaq -0xa0(%rbp), %rdx
movl %ebx, %edi
callq 0x94b6
leaq -0xa0(%rbp), %rdi
callq 0x23b8
leaq 0x8(%r15), %rsi
leaq -0x60(%rbp), %rdi
callq 0x22a0
movl 0x28(%r15), %eax
movl %eax, -0x2c(%rbp)
pushq $0x2
popq %rsi
movq %r15, %rdi
callq 0x5d06
leaq 0x70(%r15), %rax
movq %rax, -0x38(%rbp)
movq 0x70(%r15), %r12
movq 0x78(%r15), %rax
movq %rax, -0x40(%rbp)
addq $0x38, %r15
movq %r15, %r14
leaq -0xc0(%rbp), %r13
leaq -0x100(%rbp), %r15
leaq -0xe0(%rbp), %rbx
cmpq -0x40(%rbp), %r12
je 0x677f
movq %r13, %rdi
movq %r12, %rsi
callq 0x22a0
movq %r15, %rdi
movq %r13, %rsi
callq 0x22a0
movq %rbx, %rdi
leaq -0x60(%rbp), %rsi
callq 0x22a0
movq %r14, %rdi
movq %r15, %rsi
movl -0x2c(%rbp), %edx
movq %rbx, %rcx
callq 0x823c
movq %rbx, %rdi
callq 0x23b8
movq %r15, %rdi
callq 0x23b8
movq %r13, %rdi
callq 0x23b8
addq $0x20, %r12
jmp 0x6728
movq -0x38(%rbp), %rdi
callq 0x7768
movl 0x8a6e(%rip), %ebx      # 0xf1fc
decl %ebx
movl %ebx, 0x8a66(%rip)      # 0xf1fc
movb 0x8a5b(%rip), %r14b     # 0xf1f8
leaq 0x3b37(%rip), %rsi      # 0xa2db
leaq -0x80(%rbp), %rdi
leaq -0xc0(%rbp), %rdx
callq 0x530a
movsbl %r14b, %esi
leaq -0x80(%rbp), %rdx
movl %ebx, %edi
callq 0x94bc
leaq -0x80(%rbp), %rdi
callq 0x23b8
leaq -0x60(%rbp), %rdi
callq 0x23b8
addq $0xd8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x80(%rbp), %rdi
jmp 0x6836
jmp 0x6805
jmp 0x6805
movq %rax, %rbx
leaq -0xa0(%rbp), %rdi
jmp 0x683f
movq %rax, %rbx
jmp 0x6844
movq %rax, %rbx
jmp 0x683b
movq %rax, %rbx
jmp 0x682f
movq %rax, %rbx
jmp 0x6823
movq %rax, %rbx
leaq -0xe0(%rbp), %rdi
callq 0x23b8
leaq -0x100(%rbp), %rdi
callq 0x23b8
leaq -0xc0(%rbp), %rdi
callq 0x23b8
leaq -0x60(%rbp), %rdi
callq 0x23b8
movq %rbx, %rdi
callq 0x2370
// File: /workspace/github_cpp_makefile_star2_O2/Blaze2305[P]Compiler-Design-2021-Assignment/src/Parser/Parser.cpp
// Function: Parser::parseTypeListA()
void Parser::parseTypeListA(){
	tabNum+=1;
	printParseEnters(tabNum,tabChar,"parseTypeListA");
	if(checkToken(Identifier)){
		parseVarList();
		accept(Colon);
		parseType();
		accept(SemiColon);
		parseTypeListA();
	}
	tabNum-=1;
	printParseExits(tabNum,tabChar,"parseTypeListA");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movl 0x8999(%rip), %r14d     # 0xf1fc
incl %r14d
movl %r14d, 0x898f(%rip)     # 0xf1fc
movb 0x8984(%rip), %r15b     # 0xf1f8
leaq 0x3a51(%rip), %rsi      # 0xa2cc
leaq -0x60(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x530a
movsbl %r15b, %esi
leaq -0x60(%rbp), %rdx
movl %r14d, %edi
callq 0x94b6
leaq -0x60(%rbp), %rdi
callq 0x23b8
cmpl $0x0, (%rbx)
jne 0x68d4
movq %rbx, %rdi
callq 0x658e
pushq $0xe
popq %rsi
movq %rbx, %rdi
callq 0x5d06
movq %rbx, %rdi
callq 0x6678
pushq $0xf
popq %rsi
movq %rbx, %rdi
callq 0x5d06
movq %rbx, %rdi
callq 0x684c
movl 0x8922(%rip), %ebx      # 0xf1fc
decl %ebx
movl %ebx, 0x891a(%rip)      # 0xf1fc
movb 0x890f(%rip), %r14b     # 0xf1f8
leaq 0x39dc(%rip), %rsi      # 0xa2cc
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x530a
movsbl %r14b, %esi
leaq -0x40(%rbp), %rdx
movl %ebx, %edi
callq 0x94bc
leaq -0x40(%rbp), %rdi
callq 0x23b8
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
jmp 0x6932
jmp 0x6939
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x23b8
jmp 0x693c
movq %rax, %rbx
movq %rbx, %rdi
callq 0x2370
// File: /workspace/github_cpp_makefile_star2_O2/Blaze2305[P]Compiler-Design-2021-Assignment/src/Parser/Parser.cpp
// Function: Parser::parseVar()
void Parser::parseVar(){
	tabNum+=1;
	printParseEnters(tabNum,tabChar,"parseVar");
	this->symbolNamesList.push_back(this->currentToken.Value);
	accept(Identifier);
	tabNum-=1;
	printParseExits(tabNum,tabChar,"parseVar");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movl 0x88a1(%rip), %r14d     # 0xf1fc
incl %r14d
movl %r14d, 0x8897(%rip)     # 0xf1fc
movb 0x888c(%rip), %r15b     # 0xf1f8
leaq 0x397f(%rip), %rsi      # 0xa2f2
leaq -0x60(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x530a
movsbl %r15b, %esi
leaq -0x60(%rbp), %rdx
movl %r14d, %edi
callq 0x94b6
leaq -0x60(%rbp), %rdi
callq 0x23b8
leaq 0x70(%rbx), %rdi
leaq 0x8(%rbx), %rsi
callq 0x7776
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5d06
movl 0x8846(%rip), %ebx      # 0xf1fc
decl %ebx
movl %ebx, 0x883e(%rip)      # 0xf1fc
movb 0x8833(%rip), %r14b     # 0xf1f8
leaq 0x3926(%rip), %rsi      # 0xa2f2
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x530a
movsbl %r14b, %esi
leaq -0x40(%rbp), %rdx
movl %ebx, %edi
callq 0x94bc
leaq -0x40(%rbp), %rdi
callq 0x23b8
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
jmp 0x6a0e
jmp 0x6a15
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x23b8
jmp 0x6a18
movq %rax, %rbx
movq %rbx, %rdi
callq 0x2370
// File: /workspace/github_cpp_makefile_star2_O2/Blaze2305[P]Compiler-Design-2021-Assignment/src/Parser/Parser.cpp
// Function: Parser::parseStmt()
void Parser::parseStmt(){
	tabNum+=1;
	printParseEnters(tabNum,tabChar,"parseStmt");
	if(checkToken(Identifier)){
		parseAssignementStmt();
	}else if(checkToken(Read)){
		parseReadStmt();
	}else if(checkToken(Print)){
		parsePrintStmt();
	}else if(checkToken(If)){
		parseIfStmt();
	}else if(checkToken(While)){
		parseWhileStmt();
	}else{
		std::ostringstream out;
		out << "Syntax error on line ";
		out << currentToken.lineNumber;
		throw  std::runtime_error(out.str());
	}
	tabNum-=1;
	printParseExits(tabNum,tabChar,"parseStmt");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1d8, %rsp            # imm = 0x1D8
movq %rdi, %rbx
movl 0x87c2(%rip), %r14d     # 0xf1fc
incl %r14d
movl %r14d, 0x87b8(%rip)     # 0xf1fc
movb 0x87ad(%rip), %r15b     # 0xf1f8
leaq 0x38c6(%rip), %rsi      # 0xa318
leaq -0x58(%rbp), %rdi
leaq -0x1f0(%rbp), %rdx
callq 0x530a
movsbl %r15b, %esi
leaq -0x58(%rbp), %rdx
movl %r14d, %edi
callq 0x94b6
leaq -0x58(%rbp), %rdi
callq 0x23b8
movl (%rbx), %ecx
leal -0x10(%rcx), %eax
cmpl $0x4, %eax
ja 0x6a9f
leaq 0x376c(%rip), %rcx      # 0xa1f8
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movq %rbx, %rdi
callq 0x6f66
jmp 0x6ac9
testl %ecx, %ecx
jne 0x6b1b
movq %rbx, %rdi
callq 0x6cd2
jmp 0x6ac9
movq %rbx, %rdi
callq 0x6e8e
jmp 0x6ac9
movq %rbx, %rdi
callq 0x6db4
jmp 0x6ac9
movq %rbx, %rdi
callq 0x7064
movl 0x872d(%rip), %ebx      # 0xf1fc
decl %ebx
movl %ebx, 0x8725(%rip)      # 0xf1fc
movb 0x871a(%rip), %r14b     # 0xf1f8
leaq 0x3833(%rip), %rsi      # 0xa318
leaq -0x38(%rbp), %rdi
leaq -0x1f0(%rbp), %rdx
callq 0x530a
movsbl %r14b, %esi
leaq -0x38(%rbp), %rdx
movl %ebx, %edi
callq 0x94bc
leaq -0x38(%rbp), %rdi
callq 0x23b8
addq $0x1d8, %rsp            # imm = 0x1D8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq -0x1f0(%rbp), %r14
movq %r14, %rdi
callq 0x2280
leaq 0x36db(%rip), %rsi      # 0xa20c
movq %r14, %rdi
callq 0x21d0
movl 0x28(%rbx), %esi
leaq -0x1f0(%rbp), %rdi
callq 0x2360
pushq $0x10
popq %rdi
callq 0x2120
movq %rax, %r14
leaq -0x1e8(%rbp), %rsi
leaq -0x78(%rbp), %rdi
callq 0x2300
movb $0x1, %r15b
leaq -0x78(%rbp), %rsi
movq %r14, %rdi
callq 0x2310
xorl %r15d, %r15d
movq 0x8474(%rip), %rsi      # 0xeff0
movq 0x8445(%rip), %rdx      # 0xefc8
movq %r14, %rdi
callq 0x2350
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x23b8
testb %r15b, %r15b
jne 0x6ba1
jmp 0x6bae
movq %rax, %rbx
movq %r14, %rdi
callq 0x2170
jmp 0x6bae
movq %rax, %rbx
leaq -0x1f0(%rbp), %rdi
callq 0x20a0
jmp 0x6bd8
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
jmp 0x6bce
jmp 0x6bd5
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x23b8
jmp 0x6bd8
movq %rax, %rbx
movq %rbx, %rdi
callq 0x2370
// File: /workspace/github_cpp_makefile_star2_O2/Blaze2305[P]Compiler-Design-2021-Assignment/src/Parser/Parser.cpp
// Function: Parser::parseStmtListA()
void Parser::parseStmtListA(){
	tabNum+=1;
	printParseEnters(tabNum,tabChar,"parseStmtListA");
	if(checkToken(Identifier) || checkToken(Read) || checkToken(Print) || checkToken(If) || checkToken(While)){
		parseStmt();
		accept(SemiColon);
		parseStmtListA();
	}
	tabNum-=1;
	printParseExits(tabNum,tabChar,"parseStmtListA");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movl 0x8605(%rip), %r14d     # 0xf1fc
incl %r14d
movl %r14d, 0x85fb(%rip)     # 0xf1fc
movb 0x85f0(%rip), %r15b     # 0xf1f8
leaq 0x36fa(%rip), %rsi      # 0xa309
leaq -0x60(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x530a
movsbl %r15b, %esi
leaq -0x60(%rbp), %rdx
movl %r14d, %edi
callq 0x94b6
leaq -0x60(%rbp), %rdi
callq 0x23b8
movl (%rbx), %eax
cmpl $0x14, %eax
ja 0x6c61
movl $0x1d0001, %ecx         # imm = 0x1D0001
btl %eax, %ecx
jae 0x6c61
movq %rbx, %rdi
callq 0x6a20
pushq $0xf
popq %rsi
movq %rbx, %rdi
callq 0x5d06
movq %rbx, %rdi
callq 0x6be0
movl 0x8595(%rip), %ebx      # 0xf1fc
decl %ebx
movl %ebx, 0x858d(%rip)      # 0xf1fc
movb 0x8582(%rip), %r14b     # 0xf1f8
leaq 0x368c(%rip), %rsi      # 0xa309
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x530a
movsbl %r14b, %esi
leaq -0x40(%rbp), %rdx
movl %ebx, %edi
callq 0x94bc
leaq -0x40(%rbp), %rdi
callq 0x23b8
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
jmp 0x6cbf
jmp 0x6cc6
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x23b8
jmp 0x6cc9
movq %rax, %rbx
movq %rbx, %rdi
callq 0x2370
nop
// File: /workspace/github_cpp_makefile_star2_O2/Blaze2305[P]Compiler-Design-2021-Assignment/src/Parser/Parser.cpp
// Function: Parser::parseAssignementStmt()
void Parser::parseAssignementStmt(){
	tabNum+=1;
	printParseEnters(tabNum,tabChar,"parseAssignementStmt");
	accept(Identifier);
	accept(Assignment);
	parseExp();
	tabNum-=1;
	printParseExits(tabNum,tabChar,"parseAssignementStmt");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movl 0x8513(%rip), %r14d     # 0xf1fc
incl %r14d
movl %r14d, 0x8509(%rip)     # 0xf1fc
movb 0x84fe(%rip), %r15b     # 0xf1f8
leaq 0x3621(%rip), %rsi      # 0xa322
leaq -0x60(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x530a
movsbl %r15b, %esi
leaq -0x60(%rbp), %rdx
movl %r14d, %edi
callq 0x94b6
leaq -0x60(%rbp), %rdi
callq 0x23b8
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5d06
pushq $0xd
popq %rsi
movq %rbx, %rdi
callq 0x5d06
movq %rbx, %rdi
callq 0x715a
movl 0x84b2(%rip), %ebx      # 0xf1fc
decl %ebx
movl %ebx, 0x84aa(%rip)      # 0xf1fc
movb 0x849f(%rip), %r14b     # 0xf1f8
leaq 0x35c2(%rip), %rsi      # 0xa322
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x530a
movsbl %r14b, %esi
leaq -0x40(%rbp), %rdx
movl %ebx, %edi
callq 0x94bc
leaq -0x40(%rbp), %rdi
callq 0x23b8
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
jmp 0x6da2
jmp 0x6da9
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x23b8
jmp 0x6dac
movq %rax, %rbx
movq %rbx, %rdi
callq 0x2370
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movl 0x8431(%rip), %r14d     # 0xf1fc
incl %r14d
movl %r14d, 0x8427(%rip)     # 0xf1fc
movb 0x841c(%rip), %r15b     # 0xf1f8
leaq 0x3554(%rip), %rsi      # 0xa337
leaq -0x60(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x530a
movsbl %r15b, %esi
leaq -0x60(%rbp), %rdx
movl %r14d, %edi
callq 0x94b6
leaq -0x60(%rbp), %rdi
callq 0x23b8
pushq $0x13
popq %rsi
movq %rbx, %rdi
callq 0x5d06
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5d06
movl 0x83d8(%rip), %ebx      # 0xf1fc
decl %ebx
movl %ebx, 0x83d0(%rip)      # 0xf1fc
movb 0x83c5(%rip), %r14b     # 0xf1f8
leaq 0x34fd(%rip), %rsi      # 0xa337
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x530a
movsbl %r14b, %esi
leaq -0x40(%rbp), %rdx
movl %ebx, %edi
callq 0x94bc
leaq -0x40(%rbp), %rdi
callq 0x23b8
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
jmp 0x6e7c
jmp 0x6e83
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x23b8
jmp 0x6e86
movq %rax, %rbx
movq %rbx, %rdi
callq 0x2370
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movl 0x8357(%rip), %r14d     # 0xf1fc
incl %r14d
movl %r14d, 0x834d(%rip)     # 0xf1fc
movb 0x8342(%rip), %r15b     # 0xf1f8
leaq 0x3488(%rip), %rsi      # 0xa345
leaq -0x60(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x530a
movsbl %r15b, %esi
leaq -0x60(%rbp), %rdx
movl %r14d, %edi
callq 0x94b6
leaq -0x60(%rbp), %rdi
callq 0x23b8
pushq $0x14
popq %rsi
movq %rbx, %rdi
callq 0x5d06
movq %rbx, %rdi
callq 0x715a
movl 0x8300(%rip), %ebx      # 0xf1fc
decl %ebx
movl %ebx, 0x82f8(%rip)      # 0xf1fc
movb 0x82ed(%rip), %r14b     # 0xf1f8
leaq 0x3433(%rip), %rsi      # 0xa345
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x530a
movsbl %r14b, %esi
leaq -0x40(%rbp), %rdx
movl %ebx, %edi
callq 0x94bc
leaq -0x40(%rbp), %rdi
callq 0x23b8
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
jmp 0x6f54
jmp 0x6f5b
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x23b8
jmp 0x6f5e
movq %rax, %rbx
movq %rbx, %rdi
callq 0x2370
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movl 0x827f(%rip), %r14d     # 0xf1fc
incl %r14d
movl %r14d, 0x8275(%rip)     # 0xf1fc
movb 0x826a(%rip), %r15b     # 0xf1f8
leaq 0x33bf(%rip), %rsi      # 0xa354
leaq -0x60(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x530a
movsbl %r15b, %esi
leaq -0x60(%rbp), %rdx
movl %r14d, %edi
callq 0x94b6
leaq -0x60(%rbp), %rdi
callq 0x23b8
pushq $0x10
popq %rsi
movq %rbx, %rdi
callq 0x5d06
movq %rbx, %rdi
callq 0x726a
pushq $0xe
popq %rsi
movq %rbx, %rdi
callq 0x5d06
movq %rbx, %rdi
callq 0x62d6
movq %rbx, %rdi
callq 0x7394
pushq $0xb
popq %rsi
movq %rbx, %rdi
callq 0x5d06
movl 0x8202(%rip), %ebx      # 0xf1fc
decl %ebx
movl %ebx, 0x81fa(%rip)      # 0xf1fc
movb 0x81ef(%rip), %r14b     # 0xf1f8
leaq 0x3344(%rip), %rsi      # 0xa354
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x530a
movsbl %r14b, %esi
leaq -0x40(%rbp), %rdx
movl %ebx, %edi
callq 0x94bc
leaq -0x40(%rbp), %rdi
callq 0x23b8
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
jmp 0x7052
jmp 0x7059
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x23b8
jmp 0x705c
movq %rax, %rbx
movq %rbx, %rdi
callq 0x2370
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movl 0x8181(%rip), %r14d     # 0xf1fc
incl %r14d
movl %r14d, 0x8177(%rip)     # 0xf1fc
movb 0x816c(%rip), %r15b     # 0xf1f8
leaq 0x32db(%rip), %rsi      # 0xa36e
leaq -0x60(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x530a
movsbl %r15b, %esi
leaq -0x60(%rbp), %rdx
movl %r14d, %edi
callq 0x94b6
leaq -0x60(%rbp), %rdi
callq 0x23b8
pushq $0x12
popq %rsi
movq %rbx, %rdi
callq 0x5d06
movq %rbx, %rdi
callq 0x726a
pushq $0xe
popq %rsi
movq %rbx, %rdi
callq 0x5d06
movq %rbx, %rdi
callq 0x62d6
pushq $0xb
popq %rsi
movq %rbx, %rdi
callq 0x5d06
movl 0x810c(%rip), %ebx      # 0xf1fc
decl %ebx
movl %ebx, 0x8104(%rip)      # 0xf1fc
movb 0x80f9(%rip), %r14b     # 0xf1f8
leaq 0x3268(%rip), %rsi      # 0xa36e
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x530a
movsbl %r14b, %esi
leaq -0x40(%rbp), %rdx
movl %ebx, %edi
callq 0x94bc
leaq -0x40(%rbp), %rdi
callq 0x23b8
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
jmp 0x7148
jmp 0x714f
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x23b8
jmp 0x7152
movq %rax, %rbx
movq %rbx, %rdi
callq 0x2370
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movl 0x808b(%rip), %r14d     # 0xf1fc
incl %r14d
movl %r14d, 0x8081(%rip)     # 0xf1fc
movb 0x8076(%rip), %r15b     # 0xf1f8
leaq 0x3209(%rip), %rsi      # 0xa392
leaq -0x60(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x530a
movsbl %r15b, %esi
leaq -0x60(%rbp), %rdx
movl %r14d, %edi
callq 0x94b6
leaq -0x60(%rbp), %rdi
callq 0x23b8
movl (%rbx), %eax
testl %eax, %eax
je 0x71e7
cmpl $0x1, %eax
je 0x71df
cmpl $0x6, %eax
jne 0x71f9
pushq $0x6
popq %rsi
movq %rbx, %rdi
callq 0x5d06
movq %rbx, %rdi
callq 0x715a
pushq $0x7
popq %rsi
movq %rbx, %rdi
callq 0x5d06
jmp 0x71f9
pushq $0x1
popq %rsi
movq %rbx, %rdi
jmp 0x71ec
movq %rbx, %rdi
xorl %esi, %esi
callq 0x5d06
movq %rbx, %rdi
callq 0x7558
movl 0x7ffd(%rip), %ebx      # 0xf1fc
decl %ebx
movl %ebx, 0x7ff5(%rip)      # 0xf1fc
movb 0x7fea(%rip), %r14b     # 0xf1f8
leaq 0x317d(%rip), %rsi      # 0xa392
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x530a
movsbl %r14b, %esi
leaq -0x40(%rbp), %rdx
movl %ebx, %edi
callq 0x94bc
leaq -0x40(%rbp), %rdi
callq 0x23b8
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
jmp 0x7257
jmp 0x725e
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x23b8
jmp 0x7261
movq %rax, %rbx
movq %rbx, %rdi
callq 0x2370
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movl 0x7f7b(%rip), %r14d     # 0xf1fc
incl %r14d
movl %r14d, 0x7f71(%rip)     # 0xf1fc
movb 0x7f66(%rip), %r15b     # 0xf1f8
leaq 0x30e4(%rip), %rsi      # 0xa37d
leaq -0x60(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x530a
movsbl %r15b, %esi
leaq -0x60(%rbp), %rdx
movl %r14d, %edi
callq 0x94b6
leaq -0x60(%rbp), %rdi
callq 0x23b8
movl (%rbx), %eax
cmpl $0x9, %eax
je 0x72eb
cmpl $0x6, %eax
jne 0x7300
pushq $0x6
popq %rsi
movq %rbx, %rdi
callq 0x5d06
movq %rbx, %rdi
callq 0x726a
pushq $0x7
popq %rsi
movq %rbx, %rdi
callq 0x5d06
jmp 0x7323
pushq $0x9
popq %rsi
movq %rbx, %rdi
callq 0x5d06
movq %rbx, %rdi
callq 0x726a
jmp 0x731b
movq %rbx, %rdi
callq 0x715a
pushq $0x9
popq %rsi
movq %rbx, %rdi
callq 0x5d06
movq %rbx, %rdi
callq 0x715a
movq %rbx, %rdi
callq 0x7472
movl 0x7ed3(%rip), %ebx      # 0xf1fc
decl %ebx
movl %ebx, 0x7ecb(%rip)      # 0xf1fc
movb 0x7ec0(%rip), %r14b     # 0xf1f8
leaq 0x303e(%rip), %rsi      # 0xa37d
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x530a
movsbl %r14b, %esi
leaq -0x40(%rbp), %rdx
movl %ebx, %edi
callq 0x94bc
leaq -0x40(%rbp), %rdi
callq 0x23b8
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
jmp 0x7381
jmp 0x7388
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x23b8
jmp 0x738b
movq %rax, %rbx
movq %rbx, %rdi
callq 0x2370
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movl 0x7e51(%rip), %r14d     # 0xf1fc
incl %r14d
movl %r14d, 0x7e47(%rip)     # 0xf1fc
movb 0x7e3c(%rip), %r15b     # 0xf1f8
leaq 0x2f9d(%rip), %rsi      # 0xa360
leaq -0x60(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x530a
movsbl %r15b, %esi
leaq -0x60(%rbp), %rdx
movl %r14d, %edi
callq 0x94b6
leaq -0x60(%rbp), %rdi
callq 0x23b8
cmpl $0x11, (%rbx)
jne 0x7401
pushq $0x11
popq %rsi
movq %rbx, %rdi
callq 0x5d06
movq %rbx, %rdi
callq 0x62d6
movl 0x7df5(%rip), %ebx      # 0xf1fc
decl %ebx
movl %ebx, 0x7ded(%rip)      # 0xf1fc
movb 0x7de2(%rip), %r14b     # 0xf1f8
leaq 0x2f43(%rip), %rsi      # 0xa360
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x530a
movsbl %r14b, %esi
leaq -0x40(%rbp), %rdx
movl %ebx, %edi
callq 0x94bc
leaq -0x40(%rbp), %rdi
callq 0x23b8
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
jmp 0x745f
jmp 0x7466
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x23b8
jmp 0x7469
movq %rax, %rbx
movq %rbx, %rdi
callq 0x2370
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movl 0x7d73(%rip), %r14d     # 0xf1fc
incl %r14d
movl %r14d, 0x7d69(%rip)     # 0xf1fc
movb 0x7d5e(%rip), %r15b     # 0xf1f8
leaq 0x2ee6(%rip), %rsi      # 0xa387
leaq -0x60(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x530a
movsbl %r15b, %esi
leaq -0x60(%rbp), %rdx
movl %r14d, %edi
callq 0x94b6
leaq -0x60(%rbp), %rdi
callq 0x23b8
cmpl $0x9, (%rbx)
jne 0x74e7
pushq $0x9
popq %rsi
movq %rbx, %rdi
callq 0x5d06
movq %rbx, %rdi
callq 0x726a
movq %rbx, %rdi
callq 0x7472
movl 0x7d0f(%rip), %ebx      # 0xf1fc
decl %ebx
movl %ebx, 0x7d07(%rip)      # 0xf1fc
movb 0x7cfc(%rip), %r14b     # 0xf1f8
leaq 0x2e84(%rip), %rsi      # 0xa387
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x530a
movsbl %r14b, %esi
leaq -0x40(%rbp), %rdx
movl %ebx, %edi
callq 0x94bc
leaq -0x40(%rbp), %rdi
callq 0x23b8
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
jmp 0x7545
jmp 0x754c
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x23b8
jmp 0x754f
movq %rax, %rbx
movq %rbx, %rdi
callq 0x2370
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movl 0x7c8d(%rip), %r14d     # 0xf1fc
incl %r14d
movl %r14d, 0x7c83(%rip)     # 0xf1fc
movb 0x7c78(%rip), %r15b     # 0xf1f8
leaq 0x2e14(%rip), %rsi      # 0xa39b
leaq -0x60(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x530a
movsbl %r15b, %esi
leaq -0x60(%rbp), %rdx
movl %r14d, %edi
callq 0x94b6
leaq -0x60(%rbp), %rdi
callq 0x23b8
cmpl $0x3, (%rbx)
jne 0x75cd
pushq $0x3
popq %rsi
movq %rbx, %rdi
callq 0x5d06
movq %rbx, %rdi
callq 0x715a
movq %rbx, %rdi
callq 0x7558
movl 0x7c29(%rip), %ebx      # 0xf1fc
decl %ebx
movl %ebx, 0x7c21(%rip)      # 0xf1fc
movb 0x7c16(%rip), %r14b     # 0xf1f8
leaq 0x2db2(%rip), %rsi      # 0xa39b
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x530a
movsbl %r14b, %esi
leaq -0x40(%rbp), %rdx
movl %ebx, %edi
callq 0x94bc
leaq -0x40(%rbp), %rdi
callq 0x23b8
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
jmp 0x762b
jmp 0x7632
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x23b8
jmp 0x7635
movq %rax, %rbx
movq %rbx, %rdi
callq 0x2370
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movl 0x7ba7(%rip), %r14d     # 0xf1fc
incl %r14d
movl %r14d, 0x7b9d(%rip)     # 0xf1fc
movb 0x7b92(%rip), %r15b     # 0xf1f8
leaq 0x2d38(%rip), %rsi      # 0xa3a5
leaq -0x60(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x530a
movsbl %r15b, %esi
leaq -0x60(%rbp), %rdx
movl %r14d, %edi
callq 0x94b6
leaq -0x60(%rbp), %rdi
callq 0x23b8
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x5d06
movl 0x7b58(%rip), %ebx      # 0xf1fc
decl %ebx
movl %ebx, 0x7b50(%rip)      # 0xf1fc
movb 0x7b45(%rip), %r14b     # 0xf1f8
leaq 0x2ceb(%rip), %rsi      # 0xa3a5
leaq -0x40(%rbp), %rdi
leaq -0x19(%rbp), %rdx
callq 0x530a
movsbl %r14b, %esi
leaq -0x40(%rbp), %rdx
movl %ebx, %edi
callq 0x94bc
leaq -0x40(%rbp), %rdi
callq 0x23b8
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x40(%rbp), %rdi
jmp 0x76fc
jmp 0x7703
movq %rax, %rbx
leaq -0x60(%rbp), %rdi
callq 0x23b8
jmp 0x7706
movq %rax, %rbx
movq %rbx, %rdi
callq 0x2370
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movsbl (%rdi), %esi
addq $0x8, %rdi
callq 0x21a0
leaq 0x28(%rbx), %rdi
movq 0x28(%rbx), %rax
movq -0x18(%rax), %rax
andl $0xffffefff, 0x40(%rbx,%rax) # imm = 0xFFFFEFFF
leaq -0x11(%rbp), %r14
movq %r14, %rsi
callq 0x2270
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
xorl %edx, %edx
testb $0x5, 0x20(%rax,%rcx)
movzbl (%r14), %eax
cmovnel %edx, %eax
movb %al, (%rbx)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
cmpb $0xa, (%rdi)
jne 0x804d
incl 0x71b3(%rip)            # 0xf200
popq %rbp
jmp 0x7c6c
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
leaq 0x8(%rsi), %r14
leaq 0x23c0(%rip), %rsi      # 0xa433
movq %r14, %rdi
callq 0x23a0
leaq 0x2351(%rip), %r12      # 0xa3d3
leaq 0x234e(%rip), %r13      # 0xa3d7
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
callq 0x81ac
movq %r15, %rdi
cmpq %r13, %rax
je 0x80a6
callq 0x803e
jmp 0x8089
callq 0x7cba
movl %eax, 0x4(%r15)
movl %eax, (%rbx)
leaq 0x8(%rbx), %rdi
movq %r14, %rsi
callq 0x22a0
movl 0x713d(%rip), %eax      # 0xf200
movl %eax, 0x28(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x1a8, %rsp            # imm = 0x1A8
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
callq 0x8848
leaq -0x1c0(%rbp), %rdi
movq %rax, %rsi
callq 0x8898
movq %r15, %rdi
movq %rbx, %rsi
callq 0x88fc
addq $0x40, %rax
movq %rax, %rdi
movq %r14, %rsi
callq 0x2140
leaq -0x1c0(%rbp), %rdi
callq 0x7850
addq $0x1a8, %rsp            # imm = 0x1A8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rdx, %r15
movq %rax, %r14
leaq -0x1c0(%rbp), %rdi
callq 0x7850
jmp 0x84f5
movq %rdx, %r15
movq %rax, %r14
cmpl $0x1, %r15d
jne 0x85d9
movq %r14, %rdi
callq 0x2250
leaq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x8130
movq %r14, %rdi
callq 0x20d0
leaq -0x1c0(%rbp), %rdi
callq 0x2280
leaq 0x1ea9(%rip), %rsi      # 0xa3d7
leaq -0x1c0(%rbp), %rdi
callq 0x21d0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x21c0
leaq 0x1ec7(%rip), %rsi      # 0xa413
movq %rax, %rdi
callq 0x21d0
pushq $0x10
popq %rdi
callq 0x2120
movq %rax, %rbx
leaq -0x1b8(%rbp), %rsi
leaq -0x48(%rbp), %rdi
callq 0x2300
movb $0x1, %r15b
leaq -0x48(%rbp), %rsi
movq %rbx, %rdi
callq 0x2310
xorl %r15d, %r15d
movq 0x6a68(%rip), %rsi      # 0xeff0
movq 0x6a39(%rip), %rdx      # 0xefc8
movq %rbx, %rdi
callq 0x2350
movq %rax, %r14
leaq -0x48(%rbp), %rdi
callq 0x23b8
testb %r15b, %r15b
jne 0x85ad
jmp 0x85ba
movq %rax, %r14
movq %rbx, %rdi
callq 0x2170
jmp 0x85ba
movq %rax, %r14
leaq -0x1c0(%rbp), %rdi
callq 0x20a0
jmp 0x85cb
movq %rax, %r14
leaq -0x28(%rbp), %rdi
callq 0x22b0
callq 0x2320
movq %r14, %rdi
callq 0x2370
movq %rax, %rdi
callq 0x5532
nop
// File: /workspace/github_cpp_makefile_star2_O2/Blaze2305[P]Compiler-Design-2021-Assignment/src/Utils/Utils.cpp
// Function: Splitpath[abi:cxx11](char const*)
std::vector<std::string> Splitpath(const char * str){
	
	std::set<char> delims{'/'};

	std::vector<std::string> result;
	std::string temp = str;
	char const* pch = temp.c_str();
	char const* start = pch;
	for(; *pch; ++pch){
		if (delims.find(*pch) != delims.end()){
			if (start != pch){
				std::string str(start, pch);
				result.push_back(str);
			}
			else{
				result.push_back("");
			}
			start = pch + 1;
		}
	}
	result.push_back(start);

	return result;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x78(%rbp), %rsi
movb $0x2f, (%rsi)
leaq -0xa8(%rbp), %rdi
pushq $0x1
popq %rdx
leaq -0x58(%rbp), %rcx
leaq -0x29(%rbp), %r8
callq 0x9574
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq %rbx, -0x38(%rbp)
andq $0x0, 0x10(%rbx)
leaq -0x78(%rbp), %rdi
leaq -0x58(%rbp), %rdx
movq %r14, %rsi
callq 0x530a
movq -0x78(%rbp), %r14
leaq -0xa0(%rbp), %rbx
leaq -0xa8(%rbp), %r15
leaq -0x58(%rbp), %r13
movq %r14, %r12
cmpb $0x0, (%r14)
je 0x9156
movq %r15, %rdi
movq %r14, %rsi
callq 0x98b0
cmpq %rbx, %rax
je 0x9151
cmpq %r12, %r14
je 0x9126
leaq -0x48(%rbp), %rax
movq %rax, -0x58(%rbp)
movq %r13, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x55bc
movq -0x38(%rbp), %rdi
movq %r13, %rsi
callq 0x7776
jmp 0x9145
movq %r13, %rdi
leaq 0x1303(%rip), %rsi      # 0xa433
leaq -0x29(%rbp), %rdx
callq 0x530a
movq -0x38(%rbp), %rdi
movq %r13, %rsi
callq 0x9908
movq %r13, %rdi
callq 0x23b8
leaq 0x1(%r14), %r12
incq %r14
jmp 0x90e7
leaq -0x58(%rbp), %rdi
leaq -0x29(%rbp), %rdx
movq %r12, %rsi
callq 0x530a
leaq -0x58(%rbp), %rsi
movq -0x38(%rbp), %rbx
movq %rbx, %rdi
callq 0x9908
leaq -0x58(%rbp), %rdi
callq 0x23b8
leaq -0x78(%rbp), %rdi
callq 0x23b8
leaq -0xa8(%rbp), %rdi
callq 0x95b8
movq %rbx, %rax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x91b6
jmp 0x91c6
movq %rax, %r14
jmp 0x91d2
jmp 0x91b6
jmp 0x91c6
movq %rax, %r14
leaq -0x58(%rbp), %rdi
callq 0x23b8
jmp 0x91c9
jmp 0x91c6
movq %rax, %r14
leaq -0x78(%rbp), %rdi
callq 0x23b8
movq -0x38(%rbp), %rdi
callq 0x770e
leaq -0xa8(%rbp), %rdi
callq 0x95b8
movq %r14, %rdi
callq 0x2370
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movl %edx, -0x3c(%rbp)
movq %rsi, %r15
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rdi, -0x38(%rbp)
andq $0x0, 0x10(%rdi)
leaq 0x1217(%rip), %rsi      # 0xa433
leaq -0x60(%rbp), %rdi
leaq -0x29(%rbp), %rdx
callq 0x530a
movq (%r15), %r13
movq 0x8(%r15), %r12
xorl %ebx, %ebx
leaq -0x60(%rbp), %r15
cmpq %rbx, %r12
je 0x9272
movb (%r13,%rbx), %r14b
cmpb -0x3c(%rbp), %r14b
jne 0x9261
movq -0x38(%rbp), %rdi
movq %r15, %rsi
callq 0x7776
movq %r15, %rdi
leaq 0x11d7(%rip), %rsi      # 0xa433
callq 0x23a0
movsbl %r14b, %esi
movq %r15, %rdi
callq 0x21a0
incq %rbx
jmp 0x9236
leaq -0x60(%rbp), %rdi
callq 0x23b8
movq -0x38(%rbp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0x929f
movq %rax, %r14
leaq -0x60(%rbp), %rdi
callq 0x23b8
movq -0x38(%rbp), %rdi
callq 0x770e
movq %r14, %rdi
callq 0x2370