LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movl 0x8c19(%rip), %r14d     # 0x1020c
incl %r14d
movl %r14d, 0x8c0f(%rip)     # 0x1020c
movsbl 0x8c03(%rip), %r15d     # 0x10208
leaq -0x58(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x4c44(%rip), %rsi      # 0xc258
leaq 0x4c46(%rip), %rdx      # 0xc261
leaq -0x68(%rbp), %r12
movq %r12, %rdi
callq 0x644a
movl %r14d, %edi
movl %r15d, %esi
movq %r12, %rdx
callq 0xb2e1
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x764a
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
movl $0xc, %esi
callq 0x6d1c
movq %rbx, %rdi
callq 0x76fe
movq %rbx, %rdi
movl $0xb, %esi
callq 0x6d1c
movl 0x8b9a(%rip), %ebx      # 0x1020c
decl %ebx
movl %ebx, 0x8b92(%rip)      # 0x1020c
movsbl 0x8b86(%rip), %r14d     # 0x10208
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x4bc7(%rip), %rsi      # 0xc258
leaq 0x4bc9(%rip), %rdx      # 0xc261
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x644a
movl %ebx, %edi
movl %r14d, %esi
movq %r15, %rdx
callq 0xb2e7
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x76c6
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21e0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
jmp 0x76e5
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x76f6
movq (%r13), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
callq 0x2390
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movl 0x8af3(%rip), %r14d     # 0x1020c
incl %r14d
movl %r14d, 0x8ae9(%rip)     # 0x1020c
movsbl 0x8add(%rip), %r15d     # 0x10208
leaq -0x58(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x4b28(%rip), %rsi      # 0xc262
leaq 0x4b2e(%rip), %rdx      # 0xc26f
leaq -0x68(%rbp), %r12
movq %r12, %rdi
callq 0x644a
movl %r14d, %edi
movl %r15d, %esi
movq %r12, %rdx
callq 0xb2e1
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x7770
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
callq 0x7834
movq %rbx, %rdi
movl $0xe, %esi
callq 0x6d1c
movq %rbx, %rdi
callq 0x7960
movq %rbx, %rdi
movl $0xf, %esi
callq 0x6d1c
movq %rbx, %rdi
callq 0x7c7c
movl 0x8a64(%rip), %ebx      # 0x1020c
decl %ebx
movl %ebx, 0x8a5c(%rip)      # 0x1020c
movsbl 0x8a50(%rip), %r14d     # 0x10208
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x4a9b(%rip), %rsi      # 0xc262
leaq 0x4aa1(%rip), %rdx      # 0xc26f
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x644a
movl %ebx, %edi
movl %r14d, %esi
movq %r15, %rdx
callq 0xb2e7
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x77fc
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21e0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
jmp 0x781b
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x782c
movq (%r13), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
callq 0x2390
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movl 0x89bd(%rip), %r14d     # 0x1020c
incl %r14d
movl %r14d, 0x89b3(%rip)     # 0x1020c
movsbl 0x89a7(%rip), %r15d     # 0x10208
leaq -0x58(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x4a19(%rip), %rsi      # 0xc289
leaq 0x4a1e(%rip), %rdx      # 0xc295
leaq -0x68(%rbp), %r12
movq %r12, %rdi
callq 0x644a
movl %r14d, %edi
movl %r15d, %esi
movq %r12, %rdx
callq 0xb2e1
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x78a6
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21e0
cmpl $0x0, (%rbx)
jne 0x78cd
movq %rbx, %rdi
callq 0x7db8
cmpl $0x15, (%rbx)
jne 0x78cd
movq %rbx, %rdi
movl $0x15, %esi
callq 0x6d1c
movq %rbx, %rdi
callq 0x7834
movl 0x8939(%rip), %ebx      # 0x1020c
decl %ebx
movl %ebx, 0x8931(%rip)      # 0x1020c
movsbl 0x8925(%rip), %r14d     # 0x10208
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x4997(%rip), %rsi      # 0xc289
leaq 0x499c(%rip), %rdx      # 0xc295
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x644a
movl %ebx, %edi
movl %r14d, %esi
movq %r15, %rdx
callq 0xb2e7
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x7927
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21e0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
jmp 0x7946
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x7957
movq (%r13), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
callq 0x2390
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movl 0x8575(%rip), %r14d     # 0x1020c
incl %r14d
movl %r14d, 0x856b(%rip)     # 0x1020c
movsbl 0x855f(%rip), %r15d     # 0x10208
leaq -0x58(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x45b8(%rip), %rsi      # 0xc270
leaq 0x45bf(%rip), %rdx      # 0xc27e
leaq -0x68(%rbp), %r12
movq %r12, %rdi
callq 0x644a
movl %r14d, %edi
movl %r15d, %esi
movq %r12, %rdx
callq 0xb2e1
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x7cee
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21e0
cmpl $0x0, (%rbx)
jne 0x7d25
movq %rbx, %rdi
callq 0x7834
movq %rbx, %rdi
movl $0xe, %esi
callq 0x6d1c
movq %rbx, %rdi
callq 0x7960
movq %rbx, %rdi
movl $0xf, %esi
callq 0x6d1c
movq %rbx, %rdi
callq 0x7c7c
movl 0x84e1(%rip), %ebx      # 0x1020c
decl %ebx
movl %ebx, 0x84d9(%rip)      # 0x1020c
movsbl 0x84cd(%rip), %r14d     # 0x10208
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x4526(%rip), %rsi      # 0xc270
leaq 0x452d(%rip), %rdx      # 0xc27e
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x644a
movl %ebx, %edi
movl %r14d, %esi
movq %r15, %rdx
callq 0xb2e7
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x7d7f
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21e0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
jmp 0x7d9e
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x7daf
movq (%r13), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
callq 0x2390
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movl 0x8439(%rip), %r14d     # 0x1020c
incl %r14d
movl %r14d, 0x842f(%rip)     # 0x1020c
movsbl 0x8423(%rip), %r15d     # 0x10208
leaq -0x58(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x44a2(%rip), %rsi      # 0xc296
leaq 0x44a3(%rip), %rdx      # 0xc29e
leaq -0x68(%rbp), %r12
movq %r12, %rdi
callq 0x644a
movl %r14d, %edi
movl %r15d, %esi
movq %r12, %rdx
callq 0xb2e1
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x7e2a
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21e0
leaq 0x70(%rbx), %rdi
leaq 0x8(%rbx), %rsi
callq 0x8fc0
movq %rbx, %rdi
xorl %esi, %esi
callq 0x6d1c
movl 0x83c5(%rip), %ebx      # 0x1020c
decl %ebx
movl %ebx, 0x83bd(%rip)      # 0x1020c
movsbl 0x83b1(%rip), %r14d     # 0x10208
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x4430(%rip), %rsi      # 0xc296
leaq 0x4431(%rip), %rdx      # 0xc29e
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x644a
movl %ebx, %edi
movl %r14d, %esi
movq %r15, %rdx
callq 0xb2e7
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x7e9b
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21e0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
jmp 0x7eba
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x7ecb
movq (%r13), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
callq 0x2390
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movl 0x80e5(%rip), %r14d     # 0x1020c
incl %r14d
movl %r14d, 0x80db(%rip)     # 0x1020c
movsbl 0x80cf(%rip), %r15d     # 0x10208
leaq -0x58(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x4165(%rip), %rsi      # 0xc2ad
leaq 0x416c(%rip), %rdx      # 0xc2bb
leaq -0x68(%rbp), %r12
movq %r12, %rdi
callq 0x644a
movl %r14d, %edi
movl %r15d, %esi
movq %r12, %rdx
callq 0xb2e1
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x817e
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21e0
movl (%rbx), %eax
cmpl $0x14, %eax
ja 0x81ac
movl $0x1d0001, %ecx         # imm = 0x1D0001
btl %eax, %ecx
jae 0x81ac
movq %rbx, %rdi
callq 0x7ed4
movq %rbx, %rdi
movl $0xf, %esi
callq 0x6d1c
movq %rbx, %rdi
callq 0x810c
movl 0x805a(%rip), %ebx      # 0x1020c
decl %ebx
movl %ebx, 0x8052(%rip)      # 0x1020c
movsbl 0x8046(%rip), %r14d     # 0x10208
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x40dc(%rip), %rsi      # 0xc2ad
leaq 0x40e3(%rip), %rdx      # 0xc2bb
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x644a
movl %ebx, %edi
movl %r14d, %esi
movq %r15, %rdx
callq 0xb2e7
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x8206
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21e0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
jmp 0x8225
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x8236
movq (%r13), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
callq 0x2390
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movl 0x7fb3(%rip), %r14d     # 0x1020c
incl %r14d
movl %r14d, 0x7fa9(%rip)     # 0x1020c
movsbl 0x7f9d(%rip), %r15d     # 0x10208
leaq -0x58(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x404c(%rip), %rsi      # 0xc2c6
leaq 0x4059(%rip), %rdx      # 0xc2da
leaq -0x68(%rbp), %r12
movq %r12, %rdi
callq 0x644a
movl %r14d, %edi
movl %r15d, %esi
movq %r12, %rdx
callq 0xb2e1
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x82b0
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
xorl %esi, %esi
callq 0x6d1c
movq %rbx, %rdi
movl $0xd, %esi
callq 0x6d1c
movq %rbx, %rdi
callq 0x8818
movl 0x7f37(%rip), %ebx      # 0x1020c
decl %ebx
movl %ebx, 0x7f2f(%rip)      # 0x1020c
movsbl 0x7f23(%rip), %r14d     # 0x10208
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x3fd2(%rip), %rsi      # 0xc2c6
leaq 0x3fdf(%rip), %rdx      # 0xc2da
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x644a
movl %ebx, %edi
movl %r14d, %esi
movq %r15, %rdx
callq 0xb2e7
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x8329
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21e0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
jmp 0x8348
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x8359
movq (%r13), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
callq 0x2390
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movl 0x7e8f(%rip), %r14d     # 0x1020c
incl %r14d
movl %r14d, 0x7e85(%rip)     # 0x1020c
movsbl 0x7e79(%rip), %r15d     # 0x10208
leaq -0x58(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x3f3d(%rip), %rsi      # 0xc2db
leaq 0x3f43(%rip), %rdx      # 0xc2e8
leaq -0x68(%rbp), %r12
movq %r12, %rdi
callq 0x644a
movl %r14d, %edi
movl %r15d, %esi
movq %r12, %rdx
callq 0xb2e1
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x83d4
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
movl $0x13, %esi
callq 0x6d1c
movq %rbx, %rdi
xorl %esi, %esi
callq 0x6d1c
movl 0x7e1b(%rip), %ebx      # 0x1020c
decl %ebx
movl %ebx, 0x7e13(%rip)      # 0x1020c
movsbl 0x7e07(%rip), %r14d     # 0x10208
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x3ecb(%rip), %rsi      # 0xc2db
leaq 0x3ed1(%rip), %rdx      # 0xc2e8
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x644a
movl %ebx, %edi
movl %r14d, %esi
movq %r15, %rdx
callq 0xb2e7
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x8445
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21e0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
jmp 0x8464
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x8475
movq (%r13), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
callq 0x2390
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movl 0x7d73(%rip), %r14d     # 0x1020c
incl %r14d
movl %r14d, 0x7d69(%rip)     # 0x1020c
movsbl 0x7d5d(%rip), %r15d     # 0x10208
leaq -0x58(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x3e2f(%rip), %rsi      # 0xc2e9
leaq 0x3e36(%rip), %rdx      # 0xc2f7
leaq -0x68(%rbp), %r12
movq %r12, %rdi
callq 0x644a
movl %r14d, %edi
movl %r15d, %esi
movq %r12, %rdx
callq 0xb2e1
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x84f0
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
movl $0x14, %esi
callq 0x6d1c
movq %rbx, %rdi
callq 0x8818
movl 0x7d01(%rip), %ebx      # 0x1020c
decl %ebx
movl %ebx, 0x7cf9(%rip)      # 0x1020c
movsbl 0x7ced(%rip), %r14d     # 0x10208
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x3dbf(%rip), %rsi      # 0xc2e9
leaq 0x3dc6(%rip), %rdx      # 0xc2f7
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x644a
movl %ebx, %edi
movl %r14d, %esi
movq %r15, %rdx
callq 0xb2e7
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x855f
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21e0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
jmp 0x857e
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x858f
movq (%r13), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
callq 0x2390
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movl 0x7c59(%rip), %r14d     # 0x1020c
incl %r14d
movl %r14d, 0x7c4f(%rip)     # 0x1020c
movsbl 0x7c43(%rip), %r15d     # 0x10208
leaq -0x58(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x3d24(%rip), %rsi      # 0xc2f8
leaq 0x3d28(%rip), %rdx      # 0xc303
leaq -0x68(%rbp), %r12
movq %r12, %rdi
callq 0x644a
movl %r14d, %edi
movl %r15d, %esi
movq %r12, %rdx
callq 0xb2e1
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x860a
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
movl $0x10, %esi
callq 0x6d1c
movq %rbx, %rdi
callq 0x896c
movq %rbx, %rdi
movl $0xe, %esi
callq 0x6d1c
movq %rbx, %rdi
callq 0x74b6
movq %rbx, %rdi
callq 0x8ad6
movq %rbx, %rdi
movl $0xb, %esi
callq 0x6d1c
movl 0x7bbd(%rip), %ebx      # 0x1020c
decl %ebx
movl %ebx, 0x7bb5(%rip)      # 0x1020c
movsbl 0x7ba9(%rip), %r14d     # 0x10208
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x3c8a(%rip), %rsi      # 0xc2f8
leaq 0x3c8e(%rip), %rdx      # 0xc303
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x644a
movl %ebx, %edi
movl %r14d, %esi
movq %r15, %rdx
callq 0xb2e7
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x86a3
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21e0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
jmp 0x86c2
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x86d3
movq (%r13), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
callq 0x2390
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movl 0x7b15(%rip), %r14d     # 0x1020c
incl %r14d
movl %r14d, 0x7b0b(%rip)     # 0x1020c
movsbl 0x7aff(%rip), %r15d     # 0x10208
leaq -0x58(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x3bfa(%rip), %rsi      # 0xc312
leaq 0x3c01(%rip), %rdx      # 0xc320
leaq -0x68(%rbp), %r12
movq %r12, %rdi
callq 0x644a
movl %r14d, %edi
movl %r15d, %esi
movq %r12, %rdx
callq 0xb2e1
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x874e
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
movl $0x12, %esi
callq 0x6d1c
movq %rbx, %rdi
callq 0x896c
movq %rbx, %rdi
movl $0xe, %esi
callq 0x6d1c
movq %rbx, %rdi
callq 0x74b6
movq %rbx, %rdi
movl $0xb, %esi
callq 0x6d1c
movl 0x7a81(%rip), %ebx      # 0x1020c
decl %ebx
movl %ebx, 0x7a79(%rip)      # 0x1020c
movsbl 0x7a6d(%rip), %r14d     # 0x10208
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x3b68(%rip), %rsi      # 0xc312
leaq 0x3b6f(%rip), %rdx      # 0xc320
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x644a
movl %ebx, %edi
movl %r14d, %esi
movq %r15, %rdx
callq 0xb2e7
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x87df
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21e0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
jmp 0x87fe
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x880f
movq (%r13), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
callq 0x2390
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movl 0x79d9(%rip), %r14d     # 0x1020c
incl %r14d
movl %r14d, 0x79cf(%rip)     # 0x1020c
movsbl 0x79c3(%rip), %r15d     # 0x10208
leaq -0x58(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x3ae2(%rip), %rsi      # 0xc336
leaq 0x3ae3(%rip), %rdx      # 0xc33e
leaq -0x68(%rbp), %r12
movq %r12, %rdi
callq 0x644a
movl %r14d, %edi
movl %r15d, %esi
movq %r12, %rdx
callq 0xb2e1
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x888a
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21e0
movl (%rbx), %eax
testl %eax, %eax
je 0x88c8
cmpl $0x1, %eax
je 0x88be
cmpl $0x6, %eax
jne 0x88da
movq %rbx, %rdi
movl $0x6, %esi
callq 0x6d1c
movq %rbx, %rdi
callq 0x8818
movq %rbx, %rdi
movl $0x7, %esi
callq 0x6d1c
jmp 0x88da
movq %rbx, %rdi
movl $0x1, %esi
jmp 0x88cd
movq %rbx, %rdi
xorl %esi, %esi
callq 0x6d1c
movq %rbx, %rdi
callq 0x8d1a
movl 0x792c(%rip), %ebx      # 0x1020c
decl %ebx
movl %ebx, 0x7924(%rip)      # 0x1020c
movsbl 0x7918(%rip), %r14d     # 0x10208
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x3a37(%rip), %rsi      # 0xc336
leaq 0x3a38(%rip), %rdx      # 0xc33e
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x644a
movl %ebx, %edi
movl %r14d, %esi
movq %r15, %rdx
callq 0xb2e7
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x8934
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21e0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
jmp 0x8953
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x8964
movq (%r13), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
callq 0x2390
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movl 0x7885(%rip), %r14d     # 0x1020c
incl %r14d
movl %r14d, 0x787b(%rip)     # 0x1020c
movsbl 0x786f(%rip), %r15d     # 0x10208
leaq -0x58(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x3979(%rip), %rsi      # 0xc321
leaq 0x397b(%rip), %rdx      # 0xc32a
leaq -0x68(%rbp), %r12
movq %r12, %rdi
callq 0x644a
movl %r14d, %edi
movl %r15d, %esi
movq %r12, %rdx
callq 0xb2e1
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x89de
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21e0
movl (%rbx), %eax
movq %rbx, %rdi
cmpl $0x9, %eax
je 0x8a0e
cmpl $0x6, %eax
jne 0x8a22
movl $0x6, %esi
callq 0x6d1c
movq %rbx, %rdi
callq 0x896c
movq %rbx, %rdi
movl $0x7, %esi
callq 0x6d1c
jmp 0x8a44
movl $0x9, %esi
callq 0x6d1c
movq %rbx, %rdi
callq 0x896c
jmp 0x8a3c
callq 0x8818
movq %rbx, %rdi
movl $0x9, %esi
callq 0x6d1c
movq %rbx, %rdi
callq 0x8818
movq %rbx, %rdi
callq 0x8bf4
movl 0x77c2(%rip), %ebx      # 0x1020c
decl %ebx
movl %ebx, 0x77ba(%rip)      # 0x1020c
movsbl 0x77ae(%rip), %r14d     # 0x10208
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x38b8(%rip), %rsi      # 0xc321
leaq 0x38ba(%rip), %rdx      # 0xc32a
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x644a
movl %ebx, %edi
movl %r14d, %esi
movq %r15, %rdx
callq 0xb2e7
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x8a9e
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21e0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
jmp 0x8abd
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x8ace
movq (%r13), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
callq 0x2390
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movl 0x771b(%rip), %r14d     # 0x1020c
incl %r14d
movl %r14d, 0x7711(%rip)     # 0x1020c
movsbl 0x7705(%rip), %r15d     # 0x10208
leaq -0x58(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x37f2(%rip), %rsi      # 0xc304
leaq 0x37f8(%rip), %rdx      # 0xc311
leaq -0x68(%rbp), %r12
movq %r12, %rdi
callq 0x644a
movl %r14d, %edi
movl %r15d, %esi
movq %r12, %rdx
callq 0xb2e1
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x8b48
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21e0
cmpl $0x11, (%rbx)
jne 0x8b62
movq %rbx, %rdi
movl $0x11, %esi
callq 0x6d1c
movq %rbx, %rdi
callq 0x74b6
movl 0x76a4(%rip), %ebx      # 0x1020c
decl %ebx
movl %ebx, 0x769c(%rip)      # 0x1020c
movsbl 0x7690(%rip), %r14d     # 0x10208
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x377d(%rip), %rsi      # 0xc304
leaq 0x3783(%rip), %rdx      # 0xc311
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x644a
movl %ebx, %edi
movl %r14d, %esi
movq %r15, %rdx
callq 0xb2e7
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x8bbc
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21e0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
jmp 0x8bdb
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x8bec
movq (%r13), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
callq 0x2390
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movl 0x75fd(%rip), %r14d     # 0x1020c
incl %r14d
movl %r14d, 0x75f3(%rip)     # 0x1020c
movsbl 0x75e7(%rip), %r15d     # 0x10208
leaq -0x58(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x36fb(%rip), %rsi      # 0xc32b
leaq 0x36fe(%rip), %rdx      # 0xc335
leaq -0x68(%rbp), %r12
movq %r12, %rdi
callq 0x644a
movl %r14d, %edi
movl %r15d, %esi
movq %r12, %rdx
callq 0xb2e1
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x8c66
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21e0
cmpl $0x9, (%rbx)
jne 0x8c88
movq %rbx, %rdi
movl $0x9, %esi
callq 0x6d1c
movq %rbx, %rdi
callq 0x896c
movq %rbx, %rdi
callq 0x8bf4
movl 0x757e(%rip), %ebx      # 0x1020c
decl %ebx
movl %ebx, 0x7576(%rip)      # 0x1020c
movsbl 0x756a(%rip), %r14d     # 0x10208
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x367e(%rip), %rsi      # 0xc32b
leaq 0x3681(%rip), %rdx      # 0xc335
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x644a
movl %ebx, %edi
movl %r14d, %esi
movq %r15, %rdx
callq 0xb2e7
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x8ce2
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21e0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
jmp 0x8d01
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x8d12
movq (%r13), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
callq 0x2390
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movl 0x74d7(%rip), %r14d     # 0x1020c
incl %r14d
movl %r14d, 0x74cd(%rip)     # 0x1020c
movsbl 0x74c1(%rip), %r15d     # 0x10208
leaq -0x58(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x35e9(%rip), %rsi      # 0xc33f
leaq 0x35eb(%rip), %rdx      # 0xc348
leaq -0x68(%rbp), %r12
movq %r12, %rdi
callq 0x644a
movl %r14d, %edi
movl %r15d, %esi
movq %r12, %rdx
callq 0xb2e1
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x8d8c
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21e0
cmpl $0x3, (%rbx)
jne 0x8dae
movq %rbx, %rdi
movl $0x3, %esi
callq 0x6d1c
movq %rbx, %rdi
callq 0x8818
movq %rbx, %rdi
callq 0x8d1a
movl 0x7458(%rip), %ebx      # 0x1020c
decl %ebx
movl %ebx, 0x7450(%rip)      # 0x1020c
movsbl 0x7444(%rip), %r14d     # 0x10208
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x356c(%rip), %rsi      # 0xc33f
leaq 0x356e(%rip), %rdx      # 0xc348
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x644a
movl %ebx, %edi
movl %r14d, %esi
movq %r15, %rdx
callq 0xb2e7
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x8e08
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21e0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
jmp 0x8e27
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x8e38
movq (%r13), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
callq 0x2390
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
movl 0x73b1(%rip), %r14d     # 0x1020c
incl %r14d
movl %r14d, 0x73a7(%rip)     # 0x1020c
movsbl 0x739b(%rip), %r15d     # 0x10208
leaq -0x58(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x34cd(%rip), %rsi      # 0xc349
leaq 0x34d1(%rip), %rdx      # 0xc354
leaq -0x68(%rbp), %r12
movq %r12, %rdi
callq 0x644a
movl %r14d, %edi
movl %r15d, %esi
movq %r12, %rdx
callq 0xb2e1
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x8eb2
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
movl $0x1, %esi
callq 0x6d1c
movl 0x7347(%rip), %ebx      # 0x1020c
decl %ebx
movl %ebx, 0x733f(%rip)      # 0x1020c
movsbl 0x7333(%rip), %r14d     # 0x10208
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x3465(%rip), %rsi      # 0xc349
leaq 0x3469(%rip), %rdx      # 0xc354
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x644a
movl %ebx, %edi
movl %r14d, %esi
movq %r15, %rdx
callq 0xb2e7
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x8f19
movq -0x38(%rbp), %rsi
incq %rsi
callq 0x21e0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x48(%rbp), %rdi
jmp 0x8f38
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x8f49
movq (%r13), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
callq 0x2390
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x9a2b
incl 0x67e5(%rip)            # 0x10210
popq %rbp
jmp 0x94f8
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsi), %rdi
movq 0x10(%rsi), %rdx
leaq 0x2985(%rip), %rcx      # 0xc3d3
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x22f0
movzbl (%r14), %eax
cmpl $0xc, %eax
jg 0x9a73
cmpl $0x9, %eax
je 0x9a7d
cmpl $0xa, %eax
jne 0x9a87
incl 0x679f(%rip)            # 0x10210
jmp 0x9a7d
cmpl $0xd, %eax
je 0x9a7d
cmpl $0x20, %eax
jne 0x9a87
movq %r14, %rdi
callq 0x94f8
jmp 0x9a58
movq %r14, %rdi
callq 0x9546
movl %eax, 0x4(%r14)
movl %eax, (%rbx)
leaq 0x8(%rbx), %rdi
leaq 0x18(%rbx), %rax
movq %rax, 0x8(%rbx)
movq 0x8(%r14), %rsi
movq 0x10(%r14), %rdx
addq %rsi, %rdx
callq 0x67c4
movl 0x6759(%rip), %eax      # 0x10210
movl %eax, 0x28(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x78, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq -0x70(%rbp), %rsi
movb $0x2f, (%rsi)
leaq -0xa0(%rbp), %rdi
leaq -0x50(%rbp), %rcx
leaq -0x29(%rbp), %r8
movl $0x1, %edx
callq 0xb3b6
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
leaq -0x70(%rbp), %rdi
leaq -0x50(%rbp), %rdx
movq %r14, %rsi
callq 0x61e6
movq -0x70(%rbp), %rsi
movb (%rsi), %al
testb %al, %al
je 0xaf1a
leaq -0x98(%rbp), %r14
leaq -0x40(%rbp), %r13
leaq -0x50(%rbp), %r15
movq %rsi, %r12
movq -0x90(%rbp), %r9
testq %r9, %r9
je 0xaf0a
movq %r14, %r8
movq %r8, %rcx
movq %r9, %rdx
movb 0x20(%r9), %dil
xorl %r9d, %r9d
cmpb %al, %dil
setl %r9b
movq %rdx, %r8
cmovlq %rcx, %r8
movq 0x10(%rdx,%r9,8), %r9
testq %r9, %r9
jne 0xae78
cmpq %r14, %r8
je 0xaf0a
cmpb %al, %dil
cmovlq %rcx, %rdx
cmpb 0x20(%rdx), %al
jl 0xaf0a
cmpq %r12, %rsi
je 0xaecf
movq %r13, -0x50(%rbp)
movq %r15, %rdi
movq %r12, %rdx
callq 0x644a
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8fc0
jmp 0xaef0
movq %r13, -0x50(%rbp)
movq %r15, %rdi
leaq 0x14f6(%rip), %rdx      # 0xc3d3
movq %rdx, %rsi
callq 0x644a
movq %rbx, %rdi
movq %r15, %rsi
callq 0xb66a
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0xaf05
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x21e0
leaq 0x1(%r12), %rsi
movb 0x1(%r12), %al
incq %r12
testb %al, %al
jne 0xae65
leaq -0x50(%rbp), %rdi
leaq -0x29(%rbp), %rdx
callq 0x61e6
leaq -0x50(%rbp), %rsi
movq %rbx, %rdi
callq 0xb66a
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xaf4c
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x21e0
leaq -0x60(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xaf65
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x21e0
leaq -0xa0(%rbp), %rdi
callq 0xb432
movq %rbx, %rax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
jne 0xafac
jmp 0xafbd
jmp 0xafba
movq %rax, %r14
jmp 0xafd6
jmp 0xafa0
jmp 0xafba
movq %rax, %r14
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0xafbd
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x21e0
jmp 0xafbd
movq %rax, %r14
leaq -0x60(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xafd6
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
callq 0x8f52
leaq -0xa0(%rbp), %rdi
callq 0xb432
movq %r14, %rdi
callq 0x2390
// File: /workspace/github_cpp_makefile_star2_O3/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, -0x34(%rbp)
movq %rsi, %r15
xorps %xmm0, %xmm0
movups %xmm0, (%rdi)
movq %rdi, -0x30(%rbp)
movq $0x0, 0x10(%rdi)
leaq -0x48(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0x13a9(%rip), %rdx      # 0xc3d3
leaq -0x58(%rbp), %rdi
movq %rdx, %rsi
callq 0x644a
movq 0x8(%r15), %r13
testq %r13, %r13
je 0xb08a
movq (%r15), %r12
xorl %ebx, %ebx
leaq -0x58(%rbp), %r15
movb (%r12,%rbx), %r14b
cmpb -0x34(%rbp), %r14b
jne 0xb076
movq -0x30(%rbp), %rdi
movq %r15, %rsi
callq 0x8fc0
movq -0x50(%rbp), %rdx
movq %r15, %rdi
xorl %esi, %esi
leaq 0x1365(%rip), %rcx      # 0xc3d3
xorl %r8d, %r8d
callq 0x22f0
movsbl %r14b, %esi
movq %r15, %rdi
callq 0x2190
incq %rbx
cmpq %rbx, %r13
jne 0xb048
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0xb0a3
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x21e0
movq -0x30(%rbp), %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
jmp 0xb0d7
movq %rax, %r14
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0xb0d7
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x21e0
movq -0x30(%rbp), %rdi
callq 0x8f52
movq %r14, %rdi
callq 0x2390
// File: /workspace/github_cpp_makefile_star2_O3/menhits[P]phplus/src/AllOperators.cpp
// Function: AllOperators::get(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::vector<std::shared_ptr<OperatorData>, std::allocator<std::shared_ptr<OperatorData>>>&)
void AllOperators::get(string text, vector<Operator>& out)
{
	int start=0;
	int end=text.size();
	
	while (start<int(text.size()))
	{
		while (true)
		{
			if (end<=start)
			{
				error.log("operator tidak diketahui '" + text + "'", SOURCE_ERROR);
			}
			
			auto i=opsMap.find(text.substr(start, end-start));
			
			if (i==opsMap.end())
			{
				end--;
			}
			else
			{
				out.push_back(i->second);
				start=end;
				end=text.size();
				break;
			}
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, 0x40(%rsp)
movq %rdi, 0x8(%rsp)
movl 0x8(%rsi), %eax
testl %eax, %eax
jle 0xdb21
movq %rsi, %r14
leaq 0x68(%rsp), %rbp
addq $0x1f0, 0x8(%rsp)       # imm = 0x1F0
xorl %ecx, %ecx
leaq 0x10(%rsp), %r12
movslq %ecx, %rdx
movslq %eax, %r15
movq %rdx, 0x50(%rsp)
negq %rdx
movq %rdx, 0x48(%rsp)
movl %ecx, %ebx
cmpl %ecx, %r15d
jg 0xdab4
movq %r12, %rdi
leaq 0x6963d(%rip), %rsi     # 0x77046
movq %r14, %rdx
callq 0xdc11
movq %r12, %rdi
leaq 0x6e84f(%rip), %rsi     # 0x7c26a
callq 0xa560
movq %rbp, 0x58(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0xda43
movq %rdx, 0x58(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x68(%rsp)
jmp 0xda4a
movups (%rcx), %xmm0
movups %xmm0, (%rbp)
movq 0x8(%rax), %rdx
movq %rdx, 0x60(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
leaq 0x8c8a2(%rip), %rdi     # 0x9a313
leaq 0x58(%rsp), %rsi
xorl %edx, %edx
leaq 0x30(%rsp), %rcx
callq 0x1fc46
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0xda91
callq 0xdce4
movq 0x58(%rsp), %rdi
cmpq %rbp, %rdi
je 0xdaa0
callq 0xa2b0
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0xdab4
callq 0xa2b0
movq 0x48(%rsp), %rax
leaq (%rax,%r15), %rcx
movq %r12, %rdi
movq %r14, %rsi
movq 0x50(%rsp), %rdx
callq 0xa2f0
movq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0xe44e
movq %rax, %r13
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0xdaf1
callq 0xa2b0
testq %r13, %r13
jne 0xdb00
decq %r15
movl %ebx, %ecx
jmp 0xd9f4
addq $0x28, %r13
movq 0x40(%rsp), %rdi
movq %r13, %rsi
callq 0xdc92
movl 0x8(%r14), %eax
movl %r15d, %ecx
cmpl %eax, %r15d
jl 0xd9e1
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xdb55
movq %rax, %rbx
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0xdb44
callq 0xdce4
movq 0x58(%rsp), %rdi
cmpq %rbp, %rdi
je 0xdb58
callq 0xa2b0
jmp 0xdb58
movq %rax, %rbx
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0xdb6c
callq 0xa2b0
movq %rbx, %rdi
callq 0xa510
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r14
pushq %rbx
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x28(%rdi), %rax
movq %rax, 0x28(%rsi)
leaq 0x30(%rsi), %rdi
leaq 0x30(%r14), %rsi
callq 0xdea2
movq 0x38(%r14), %rax
movq %rax, 0x38(%rbx)
leaq 0x40(%rbx), %rdi
leaq 0x40(%r14), %rsi
callq 0xdea2
leaq 0x8(%r14), %rsi
leaq 0x8(%rbx), %rdi
callq 0xa1d0
testl %ebp, %ebp
je 0xe69e
movq 0x48(%r14), %rax
movq %rax, 0x48(%rbx)
leaq 0x50(%rbx), %rdi
leaq 0x50(%r14), %rsi
callq 0xdea2
movq 0x58(%r14), %rax
movq %rax, 0x58(%rbx)
leaq 0x60(%rbx), %rdi
leaq 0x60(%r14), %rsi
callq 0xdea2
movb 0x68(%r14), %al
movb %al, 0x68(%rbx)
movq 0x70(%r14), %rax
movq %rax, 0x70(%rbx)
leaq 0x78(%rbx), %rdi
leaq 0x78(%r14), %rsi
callq 0xdea2
movb 0x80(%r14), %al
movb %al, 0x80(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movq $0x0, 0x10(%rsp)
movq 0x88(%rsi), %rax
movq 0x90(%rsi), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
testl %ecx, %ecx
jle 0xe737
movq %rsi, %r14
leaq 0x28(%rsp), %r13
xorl %ebp, %ebp
leaq 0x18(%rsp), %r15
movq %rsp, %r12
movq (%rax,%rbp,8), %rsi
movq (%rsi), %rax
movq %r15, %rdi
callq *0x18(%rax)
movq %r12, %rdi
movq %r15, %rsi
callq 0x17280
movq 0x18(%rsp), %rdi
cmpq %r13, %rdi
je 0xe717
callq 0xa2b0
incq %rbp
movq 0x88(%r14), %rax
movq 0x90(%r14), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
movslq %ecx, %rcx
cmpq %rcx, %rbp
jl 0xe6f0
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x7158b
movq %rsp, %rdi
callq 0x14adc
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xe75e
movq %rax, %rbx
jmp 0xe775
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r13, %rdi
je 0xe775
callq 0xa2b0
movq %rsp, %rdi
callq 0x14adc
movq %rbx, %rdi
callq 0xa510
nop
// File: /workspace/github_cpp_makefile_star2_O3/menhits[P]phplus/src/AstNode.cpp
// Function: AstFuncBody::getString[abi:cxx11]()
string AstFuncBody::getString()
{
	vector<string> data;
	
	data.push_back("function");
	
	vector<string> types={leftTypeNode->getString(), rightTypeNode->getString(), returnTypeNode->getString()};
	
	data.push_back(str::makeList(types));
	
	data.push_back(bodyNode->getString());
	
	return str::makeList(data);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
leaq 0x38(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x68527(%rip), %rsi     # 0x771f8
leaq 0x68528(%rip), %rdx     # 0x77200
leaq 0x28(%rsp), %rdi
callq 0xdfa8
leaq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x17280
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0xed00
callq 0xa2b0
movq 0x88(%r14), %rsi
movq (%rsi), %rax
leaq 0x28(%rsp), %r15
movq %r15, %rdi
callq *0x18(%rax)
leaq 0x48(%rsp), %r12
movq 0x90(%r14), %rsi
movq (%rsi), %rax
movq %r12, %rdi
callq *0x18(%rax)
leaq 0x68(%rsp), %r12
movq 0x98(%r14), %rsi
movq (%rsi), %rax
movq %r12, %rdi
callq *0x18(%rax)
leaq 0x88(%rsp), %rdi
leaq 0x28(%rsp), %rsi
leaq 0xf(%rsp), %rcx
movl $0x3, %edx
callq 0x15016
leaq 0x78(%rsp), %r15
xorl %r12d, %r12d
movq 0x68(%rsp,%r12), %rdi
leaq (%r15,%r12), %rax
cmpq %rdi, %rax
je 0xed76
callq 0xa2b0
addq $-0x20, %r12
cmpq $-0x60, %r12
jne 0xed63
leaq 0x28(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x7158b
leaq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x17280
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0xedb0
callq 0xa2b0
movq 0xa0(%r14), %rsi
movq (%rsi), %rax
leaq 0x28(%rsp), %rdi
callq *0x18(%rax)
leaq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x17280
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0xede0
callq 0xa2b0
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x7158b
leaq 0x88(%rsp), %rdi
callq 0x14adc
leaq 0x10(%rsp), %rdi
callq 0x14adc
movq %rbx, %rax
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0xee32
jmp 0xee1e
jmp 0xee32
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0xee35
callq 0xa2b0
jmp 0xee35
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0x14adc
jmp 0xeeaf
movq %rax, %rbx
movq $-0x60, %r14
leaq 0x78(%rsp), %r15
movq -0x10(%r15), %rdi
cmpq %rdi, %r15
je 0xee61
callq 0xa2b0
addq $-0x20, %r15
addq $0x20, %r14
jne 0xee53
jmp 0xeeaf
jmp 0xee83
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0xeeaf
callq 0xa2b0
jmp 0xeeaf
movq %rax, %rbx
jmp 0xeeaf
movq %rax, %rbx
addq $-0x10, %r12
movq -0x10(%r12), %rdi
cmpq %rdi, %r12
je 0xee9e
callq 0xa2b0
leaq -0x20(%r12), %rax
addq $-0x10, %r12
cmpq %r15, %r12
movq %rax, %r12
jne 0xee8f
leaq 0x10(%rsp), %rdi
callq 0x14adc
movq %rbx, %rdi
callq 0xa510
nop