LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7c43(%rip), %r14d     # 0x1020c
incl %r14d
movl %r14d, 0x7c39(%rip)     # 0x1020c
movsbl 0x7c2d(%rip), %r15d     # 0x10208
leaq -0x58(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x3d0e(%rip), %rsi      # 0xc2f8
leaq 0x3d12(%rip), %rdx      # 0xc303
leaq -0x68(%rbp), %r12
movq %r12, %rdi
callq 0x644a
movl %r14d, %edi
movl %r15d, %esi
movq %r12, %rdx
callq 0xb315
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x8620
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
movl $0x10, %esi
callq 0x6d1c
movq %rbx, %rdi
callq 0x8982
movq %rbx, %rdi
movl $0xe, %esi
callq 0x6d1c
movq %rbx, %rdi
callq 0x74be
movq %rbx, %rdi
callq 0x8aec
movq %rbx, %rdi
movl $0xb, %esi
callq 0x6d1c
movl 0x7ba7(%rip), %ebx      # 0x1020c
decl %ebx
movl %ebx, 0x7b9f(%rip)      # 0x1020c
movsbl 0x7b93(%rip), %r14d     # 0x10208
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x3c74(%rip), %rsi      # 0xc2f8
leaq 0x3c78(%rip), %rdx      # 0xc303
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x644a
movl %ebx, %edi
movl %r14d, %esi
movq %r15, %rdx
callq 0xb31b
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x86b9
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 0x86d8
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x86e9
movq (%r13), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
callq 0x2390
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7aff(%rip), %r14d     # 0x1020c
incl %r14d
movl %r14d, 0x7af5(%rip)     # 0x1020c
movsbl 0x7ae9(%rip), %r15d     # 0x10208
leaq -0x58(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x3be4(%rip), %rsi      # 0xc312
leaq 0x3beb(%rip), %rdx      # 0xc320
leaq -0x68(%rbp), %r12
movq %r12, %rdi
callq 0x644a
movl %r14d, %edi
movl %r15d, %esi
movq %r12, %rdx
callq 0xb315
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x8764
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
movl $0x12, %esi
callq 0x6d1c
movq %rbx, %rdi
callq 0x8982
movq %rbx, %rdi
movl $0xe, %esi
callq 0x6d1c
movq %rbx, %rdi
callq 0x74be
movq %rbx, %rdi
movl $0xb, %esi
callq 0x6d1c
movl 0x7a6b(%rip), %ebx      # 0x1020c
decl %ebx
movl %ebx, 0x7a63(%rip)      # 0x1020c
movsbl 0x7a57(%rip), %r14d     # 0x10208
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x3b52(%rip), %rsi      # 0xc312
leaq 0x3b59(%rip), %rdx      # 0xc320
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x644a
movl %ebx, %edi
movl %r14d, %esi
movq %r15, %rdx
callq 0xb31b
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x87f5
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 0x8814
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x8825
movq (%r13), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
callq 0x2390
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x79c3(%rip), %r14d     # 0x1020c
incl %r14d
movl %r14d, 0x79b9(%rip)     # 0x1020c
movsbl 0x79ad(%rip), %r15d     # 0x10208
leaq -0x58(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x3acc(%rip), %rsi      # 0xc336
leaq 0x3acd(%rip), %rdx      # 0xc33e
leaq -0x68(%rbp), %r12
movq %r12, %rdi
callq 0x644a
movl %r14d, %edi
movl %r15d, %esi
movq %r12, %rdx
callq 0xb315
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x88a0
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21e0
movl (%rbx), %eax
testl %eax, %eax
je 0x88de
cmpl $0x1, %eax
je 0x88d4
cmpl $0x6, %eax
jne 0x88f0
movq %rbx, %rdi
movl $0x6, %esi
callq 0x6d1c
movq %rbx, %rdi
callq 0x882e
movq %rbx, %rdi
movl $0x7, %esi
callq 0x6d1c
jmp 0x88f0
movq %rbx, %rdi
movl $0x1, %esi
jmp 0x88e3
movq %rbx, %rdi
xorl %esi, %esi
callq 0x6d1c
movq %rbx, %rdi
callq 0x8d30
movl 0x7916(%rip), %ebx      # 0x1020c
decl %ebx
movl %ebx, 0x790e(%rip)      # 0x1020c
movsbl 0x7902(%rip), %r14d     # 0x10208
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x3a21(%rip), %rsi      # 0xc336
leaq 0x3a22(%rip), %rdx      # 0xc33e
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x644a
movl %ebx, %edi
movl %r14d, %esi
movq %r15, %rdx
callq 0xb31b
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x894a
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 0x8969
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x897a
movq (%r13), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
callq 0x2390
// File: /workspace/github_cpp_makefile_star2_O1/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 0x786f(%rip), %r14d     # 0x1020c
incl %r14d
movl %r14d, 0x7865(%rip)     # 0x1020c
movsbl 0x7859(%rip), %r15d     # 0x10208
leaq -0x58(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x3963(%rip), %rsi      # 0xc321
leaq 0x3965(%rip), %rdx      # 0xc32a
leaq -0x68(%rbp), %r12
movq %r12, %rdi
callq 0x644a
movl %r14d, %edi
movl %r15d, %esi
movq %r12, %rdx
callq 0xb315
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x89f4
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21e0
movl (%rbx), %eax
movq %rbx, %rdi
cmpl $0x9, %eax
je 0x8a24
cmpl $0x6, %eax
jne 0x8a38
movl $0x6, %esi
callq 0x6d1c
movq %rbx, %rdi
callq 0x8982
movq %rbx, %rdi
movl $0x7, %esi
callq 0x6d1c
jmp 0x8a5a
movl $0x9, %esi
callq 0x6d1c
movq %rbx, %rdi
callq 0x8982
jmp 0x8a52
callq 0x882e
movq %rbx, %rdi
movl $0x9, %esi
callq 0x6d1c
movq %rbx, %rdi
callq 0x882e
movq %rbx, %rdi
callq 0x8c0a
movl 0x77ac(%rip), %ebx      # 0x1020c
decl %ebx
movl %ebx, 0x77a4(%rip)      # 0x1020c
movsbl 0x7798(%rip), %r14d     # 0x10208
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x38a2(%rip), %rsi      # 0xc321
leaq 0x38a4(%rip), %rdx      # 0xc32a
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x644a
movl %ebx, %edi
movl %r14d, %esi
movq %r15, %rdx
callq 0xb31b
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x8ab4
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 0x8ad3
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x8ae4
movq (%r13), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
callq 0x2390
// File: /workspace/github_cpp_makefile_star2_O1/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 0x7705(%rip), %r14d     # 0x1020c
incl %r14d
movl %r14d, 0x76fb(%rip)     # 0x1020c
movsbl 0x76ef(%rip), %r15d     # 0x10208
leaq -0x58(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x37dc(%rip), %rsi      # 0xc304
leaq 0x37e2(%rip), %rdx      # 0xc311
leaq -0x68(%rbp), %r12
movq %r12, %rdi
callq 0x644a
movl %r14d, %edi
movl %r15d, %esi
movq %r12, %rdx
callq 0xb315
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x8b5e
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21e0
cmpl $0x11, (%rbx)
jne 0x8b78
movq %rbx, %rdi
movl $0x11, %esi
callq 0x6d1c
movq %rbx, %rdi
callq 0x74be
movl 0x768e(%rip), %ebx      # 0x1020c
decl %ebx
movl %ebx, 0x7686(%rip)      # 0x1020c
movsbl 0x767a(%rip), %r14d     # 0x10208
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x3767(%rip), %rsi      # 0xc304
leaq 0x376d(%rip), %rdx      # 0xc311
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x644a
movl %ebx, %edi
movl %r14d, %esi
movq %r15, %rdx
callq 0xb31b
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x8bd2
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 0x8bf1
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x8c02
movq (%r13), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
callq 0x2390
// File: /workspace/github_cpp_makefile_star2_O1/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 0x75e7(%rip), %r14d     # 0x1020c
incl %r14d
movl %r14d, 0x75dd(%rip)     # 0x1020c
movsbl 0x75d1(%rip), %r15d     # 0x10208
leaq -0x58(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x36e5(%rip), %rsi      # 0xc32b
leaq 0x36e8(%rip), %rdx      # 0xc335
leaq -0x68(%rbp), %r12
movq %r12, %rdi
callq 0x644a
movl %r14d, %edi
movl %r15d, %esi
movq %r12, %rdx
callq 0xb315
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x8c7c
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21e0
cmpl $0x9, (%rbx)
jne 0x8c9e
movq %rbx, %rdi
movl $0x9, %esi
callq 0x6d1c
movq %rbx, %rdi
callq 0x8982
movq %rbx, %rdi
callq 0x8c0a
movl 0x7568(%rip), %ebx      # 0x1020c
decl %ebx
movl %ebx, 0x7560(%rip)      # 0x1020c
movsbl 0x7554(%rip), %r14d     # 0x10208
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x3668(%rip), %rsi      # 0xc32b
leaq 0x366b(%rip), %rdx      # 0xc335
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x644a
movl %ebx, %edi
movl %r14d, %esi
movq %r15, %rdx
callq 0xb31b
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x8cf8
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 0x8d17
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x8d28
movq (%r13), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
callq 0x2390
// File: /workspace/github_cpp_makefile_star2_O1/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 0x74c1(%rip), %r14d     # 0x1020c
incl %r14d
movl %r14d, 0x74b7(%rip)     # 0x1020c
movsbl 0x74ab(%rip), %r15d     # 0x10208
leaq -0x58(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x35d3(%rip), %rsi      # 0xc33f
leaq 0x35d5(%rip), %rdx      # 0xc348
leaq -0x68(%rbp), %r12
movq %r12, %rdi
callq 0x644a
movl %r14d, %edi
movl %r15d, %esi
movq %r12, %rdx
callq 0xb315
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x8da2
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21e0
cmpl $0x3, (%rbx)
jne 0x8dc4
movq %rbx, %rdi
movl $0x3, %esi
callq 0x6d1c
movq %rbx, %rdi
callq 0x882e
movq %rbx, %rdi
callq 0x8d30
movl 0x7442(%rip), %ebx      # 0x1020c
decl %ebx
movl %ebx, 0x743a(%rip)      # 0x1020c
movsbl 0x742e(%rip), %r14d     # 0x10208
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x3556(%rip), %rsi      # 0xc33f
leaq 0x3558(%rip), %rdx      # 0xc348
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x644a
movl %ebx, %edi
movl %r14d, %esi
movq %r15, %rdx
callq 0xb31b
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x8e1e
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 0x8e3d
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x8e4e
movq (%r13), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
callq 0x2390
// File: /workspace/github_cpp_makefile_star2_O1/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 0x739b(%rip), %r14d     # 0x1020c
incl %r14d
movl %r14d, 0x7391(%rip)     # 0x1020c
movsbl 0x7385(%rip), %r15d     # 0x10208
leaq -0x58(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x34b7(%rip), %rsi      # 0xc349
leaq 0x34bb(%rip), %rdx      # 0xc354
leaq -0x68(%rbp), %r12
movq %r12, %rdi
callq 0x644a
movl %r14d, %edi
movl %r15d, %esi
movq %r12, %rdx
callq 0xb315
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x8ec8
movq -0x58(%rbp), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
movl $0x1, %esi
callq 0x6d1c
movl 0x7331(%rip), %ebx      # 0x1020c
decl %ebx
movl %ebx, 0x7329(%rip)      # 0x1020c
movsbl 0x731d(%rip), %r14d     # 0x10208
leaq -0x38(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x344f(%rip), %rsi      # 0xc349
leaq 0x3453(%rip), %rdx      # 0xc354
leaq -0x48(%rbp), %r15
movq %r15, %rdi
callq 0x644a
movl %ebx, %edi
movl %r14d, %esi
movq %r15, %rdx
callq 0xb31b
movq -0x48(%rbp), %rdi
cmpq %r13, %rdi
je 0x8f2f
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 0x8f4e
movq %rax, %rbx
movq -0x68(%rbp), %rdi
cmpq %r13, %rdi
je 0x8f5f
movq (%r13), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
callq 0x2390
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2190
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 0x2280
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_O1/Blaze2305[P]Compiler-Design-2021-Assignment/src/Scanner/Scanner.cpp
// Function: Scanner::discardChar()
void Scanner::discardChar(){
	char ch;
	if(inFile >> std::noskipws >> ch){
		this->currentChar = ch;
		// std::cout<<"CURRENT CHAR:  "<< this->currentChar << std::endl;
	}else{
		this->currentChar = '\u0000';
	}
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
addq $0x28, %rdi
movq 0x28(%rbx), %rax
movq -0x18(%rax), %rax
andl $0xffffefff, 0x40(%rbx,%rax) # imm = 0xFFFFEFFF
leaq -0x11(%rbp), %r14
movq %r14, %rsi
callq 0x2280
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_O1/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 0x9a67
incl 0x67a9(%rip)            # 0x10210
popq %rbp
jmp 0x9534
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x2949(%rip), %rcx      # 0xc3d3
xorl %esi, %esi
xorl %r8d, %r8d
callq 0x22f0
movzbl (%r14), %eax
cmpl $0x20, %eax
jne 0x9aa4
cmpl $0xa, %eax
je 0x9aba
jmp 0x9ac0
cmpl $0x9, %eax
je 0x9ac0
cmpl $0xa, %eax
je 0x9aba
cmpl $0xd, %eax
je 0x9ac0
cmpl $0x20, %eax
je 0x9a9d
jmp 0x9aca
incl 0x6750(%rip)            # 0x10210
movq %r14, %rdi
callq 0x9534
jmp 0x9a94
movq %r14, %rdi
callq 0x9582
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 0x67ca
movl 0x6716(%rip), %eax      # 0x10210
movl %eax, 0x28(%rbx)
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xb3ea
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 0xaf4e
leaq -0x98(%rbp), %r14
leaq -0x40(%rbp), %r13
leaq -0x50(%rbp), %r15
movq %rsi, %r12
movq -0x90(%rbp), %rdx
movq %r14, %rcx
testq %rdx, %rdx
je 0xaecb
movq %r14, %rcx
xorl %edi, %edi
cmpb %al, 0x20(%rdx)
setl %dil
cmovgeq %rdx, %rcx
movq 0x10(%rdx,%rdi,8), %rdx
testq %rdx, %rdx
jne 0xaeb4
movq %r14, %rdx
cmpq %r14, %rcx
je 0xaedd
cmpb 0x20(%rcx), %al
cmovlq %r14, %rcx
movq %rcx, %rdx
cmpq %r14, %rdx
je 0xaf3e
cmpq %r12, %rsi
je 0xaf03
movq %r13, -0x50(%rbp)
movq %r15, %rdi
movq %r12, %rdx
callq 0x644a
movq %rbx, %rdi
movq %r15, %rsi
callq 0x8fd2
jmp 0xaf24
movq %r13, -0x50(%rbp)
movq %r15, %rdi
leaq 0x14c2(%rip), %rdx      # 0xc3d3
movq %rdx, %rsi
callq 0x644a
movq %rbx, %rdi
movq %r15, %rsi
callq 0xb6aa
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0xaf39
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x21e0
leaq 0x1(%r12), %rsi
movb 0x1(%r12), %al
incq %r12
testb %al, %al
jne 0xaea2
leaq -0x50(%rbp), %rdi
leaq -0x29(%rbp), %rdx
callq 0x61e6
leaq -0x50(%rbp), %rsi
movq %rbx, %rdi
callq 0xb6aa
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xaf80
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x21e0
leaq -0x60(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xaf99
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x21e0
leaq -0xa0(%rbp), %rdi
callq 0xb466
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 0xafe0
jmp 0xaff1
jmp 0xafee
movq %rax, %r14
jmp 0xb00a
jmp 0xafd4
jmp 0xafee
movq %rax, %r14
movq -0x50(%rbp), %rdi
cmpq %r13, %rdi
je 0xaff1
movq -0x40(%rbp), %rsi
incq %rsi
callq 0x21e0
jmp 0xaff1
movq %rax, %r14
leaq -0x60(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xb00a
movq -0x60(%rbp), %rsi
incq %rsi
callq 0x21e0
movq %rbx, %rdi
callq 0x8f68
leaq -0xa0(%rbp), %rdi
callq 0xb466
movq %r14, %rdi
callq 0x2390
// File: /workspace/github_cpp_makefile_star2_O1/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 0x1375(%rip), %rdx      # 0xc3d3
leaq -0x58(%rbp), %rdi
movq %rdx, %rsi
callq 0x644a
movq 0x8(%r15), %r13
testq %r13, %r13
je 0xb0be
movq (%r15), %r12
xorl %ebx, %ebx
leaq -0x58(%rbp), %r15
movb (%r12,%rbx), %r14b
cmpb -0x34(%rbp), %r14b
jne 0xb0aa
movq -0x30(%rbp), %rdi
movq %r15, %rsi
callq 0x8fd2
movq -0x50(%rbp), %rdx
movq %r15, %rdi
xorl %esi, %esi
leaq 0x1331(%rip), %rcx      # 0xc3d3
xorl %r8d, %r8d
callq 0x22f0
movsbl %r14b, %esi
movq %r15, %rdi
callq 0x2190
incq %rbx
cmpq %rbx, %r13
jne 0xb07c
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0xb0d7
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 0xb10b
movq %rax, %r14
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0xb10b
movq -0x48(%rbp), %rsi
incq %rsi
callq 0x21e0
movq -0x30(%rbp), %rdi
callq 0x8f68
movq %r14, %rdi
callq 0x2390
// File: /workspace/github_cpp_makefile_star2_O1/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 $0x68, %rsp
movq %rdx, 0x40(%rsp)
movq %rdi, 0x8(%rsp)
cmpl $0x0, 0x8(%rsi)
jle 0xdafe
movq %rsi, %r14
movl 0x8(%rsi), %ebx
leaq 0x58(%rsp), %r15
addq $0x1f0, 0x8(%rsp)       # imm = 0x1F0
xorl %r13d, %r13d
leaq 0x10(%rsp), %r12
movl %ebx, %ebp
subl %r13d, %ebp
jg 0xda98
movq %r12, %rdi
leaq 0x68659(%rip), %rsi     # 0x76046
movq %r14, %rdx
callq 0xdbef
movq %r12, %rdi
leaq 0x6d8ab(%rip), %rsi     # 0x7b2aa
callq 0xa560
movq %r15, 0x48(%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0xda27
movq %rdx, 0x48(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x58(%rsp)
jmp 0xda2e
movups (%rcx), %xmm0
movups %xmm0, (%r15)
movq 0x8(%rax), %rdx
movq %rdx, 0x50(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
leaq 0x8b8be(%rip), %rdi     # 0x99313
leaq 0x48(%rsp), %rsi
xorl %edx, %edx
leaq 0x30(%rsp), %rcx
callq 0x1f926
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0xda75
callq 0xdcba
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0xda84
callq 0xa2b0
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0xda98
callq 0xa2b0
movslq %r13d, %rdx
movslq %ebp, %rcx
movq %r12, %rdi
movq %r14, %rsi
callq 0xa2f0
movq 0x8(%rsp), %rdi
movq %r12, %rsi
callq 0xe414
movq %rax, %rbp
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0xdacd
callq 0xa2b0
testq %rbp, %rbp
je 0xdae9
leaq 0x28(%rbp), %rsi
movq 0x40(%rsp), %rdi
callq 0xdc70
movl %ebx, %r13d
movl 0x8(%r14), %ebx
jmp 0xdaeb
decl %ebx
testq %rbp, %rbp
je 0xd9d8
cmpl 0x8(%r14), %r13d
jl 0xd9d8
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0xdb1f
callq 0xdcba
movq 0x48(%rsp), %rdi
cmpq %r15, %rdi
je 0xdb35
callq 0xa2b0
jmp 0xdb35
jmp 0xdb32
movq %rax, %rbx
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0xdb49
callq 0xa2b0
movq %rbx, %rdi
callq 0xa510
nop
// File: /workspace/github_cpp_makefile_star2_O1/menhits[P]phplus/src/../h/Operator.h
// Function: OperatorData::OperatorData(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, OperatorData::InputTaken, bool)
OperatorData(string textIn, int precedenceIn, InputTaken inputIn, bool overloadableIn)
	{
		text=textIn;
		precedence=precedenceIn;
		input=inputIn;
		overloadable=overloadableIn;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebp
movl %ecx, %r14d
movl %edx, %r15d
movq %rdi, %rbx
leaq 0x10(%rdi), %r12
movq %r12, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
callq 0xa1d0
movl %r15d, 0x20(%rbx)
movl %r14d, 0x28(%rbx)
movb %bpl, 0x24(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq (%rbx), %rdi
cmpq %r12, %rdi
je 0xdbe7
callq 0xa2b0
movq %r14, %rdi
callq 0xa510
// File: /workspace/github_cpp_makefile_star2_O1/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 0xde72
movq 0x38(%r14), %rax
movq %rax, 0x38(%rbx)
leaq 0x40(%rbx), %rdi
leaq 0x40(%r14), %rsi
callq 0xde72
leaq 0x8(%r14), %rsi
leaq 0x8(%rbx), %rdi
callq 0xa1d0
testl %ebp, %ebp
je 0xe66a
movq 0x48(%r14), %rax
movq %rax, 0x48(%rbx)
leaq 0x50(%rbx), %rdi
leaq 0x50(%r14), %rsi
callq 0xde72
movq 0x58(%r14), %rax
movq %rax, 0x58(%rbx)
leaq 0x60(%rbx), %rdi
leaq 0x60(%r14), %rsi
callq 0xde72
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 0xde72
movb 0x80(%r14), %al
movb %al, 0x80(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0xe703
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 0x16ffe
movq 0x18(%rsp), %rdi
cmpq %r13, %rdi
je 0xe6e3
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 0xe6bc
movq %rsp, %rsi
movq %rbx, %rdi
callq 0x7061f
movq %rsp, %rdi
callq 0x148b4
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0xe72a
movq %rax, %rbx
jmp 0xe741
movq %rax, %rbx
movq 0x18(%rsp), %rdi
cmpq %r13, %rdi
je 0xe741
callq 0xa2b0
movq %rsp, %rdi
callq 0x148b4
movq %rbx, %rdi
callq 0xa510
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6757f(%rip), %rsi     # 0x761f8
leaq 0x67580(%rip), %rdx     # 0x76200
leaq 0x28(%rsp), %rdi
callq 0xdf6a
leaq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %r15
movq %r15, %rsi
callq 0x16ffe
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0xecab
callq 0xa2b0
movq 0x88(%r14), %rsi
movq (%rsi), %rax
movq %r15, %r12
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 0x14dbc
leaq 0x78(%rsp), %r15
xorl %r12d, %r12d
movq 0x68(%rsp,%r12), %rdi
leaq (%r15,%r12), %rax
cmpq %rdi, %rax
je 0xed1f
callq 0xa2b0
addq $-0x20, %r12
cmpq $-0x60, %r12
jne 0xed0c
leaq 0x28(%rsp), %rdi
leaq 0x88(%rsp), %rsi
callq 0x7061f
leaq 0x10(%rsp), %rdi
leaq 0x28(%rsp), %rsi
callq 0x16ffe
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0xed59
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 0x16ffe
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0xed89
callq 0xa2b0
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x7061f
leaq 0x88(%rsp), %rdi
callq 0x148b4
leaq 0x10(%rsp), %rdi
callq 0x148b4
movq %rbx, %rax
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0xeddb
jmp 0xedc7
jmp 0xeddb
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0xedde
callq 0xa2b0
jmp 0xedde
movq %rax, %rbx
leaq 0x88(%rsp), %rdi
callq 0x148b4
jmp 0xee60
movq %rax, %rbx
movq $-0x60, %r14
leaq 0x78(%rsp), %r15
movq -0x10(%r15), %rdi
cmpq %rdi, %r15
je 0xee0a
callq 0xa2b0
addq $-0x20, %r15
addq $0x20, %r14
jne 0xedfc
jmp 0xee60
movq %rax, %rbx
movq 0x28(%rsp), %rdi
cmpq %r13, %rdi
je 0xee60
callq 0xa2b0
jmp 0xee60
movq %rax, %rbx
jmp 0xee60
movq %rax, %rbx
cmpq %r12, %r15
je 0xee60
addq $-0x10, %r12
leaq 0x28(%rsp), %r14
movq -0x10(%r12), %rdi
cmpq %rdi, %r12
je 0xee4f
callq 0xa2b0
leaq -0x20(%r12), %rax
addq $-0x10, %r12
cmpq %r14, %r12
movq %rax, %r12
jne 0xee40
leaq 0x10(%rsp), %rdi
callq 0x148b4
movq %rbx, %rdi
callq 0xa510
// File: /workspace/github_cpp_makefile_star2_O1/menhits[P]phplus/src/AstNode.cpp
// Function: AstExpression::getString[abi:cxx11]()
string AstExpression::getString()
{
	string leftStr;
	if (!leftIn->isVoid())
	{
		leftStr=leftIn->getString();
	}
	
	string centerStr=center->getString();
	
	string rightStr;
	if (!rightIn->isVoid())
	{
		rightStr=rightIn->getString();
	}
	
	return str::makeRootUpBinaryTree(centerStr, "", "", leftStr, rightStr);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x90(%rsp), %r12
movq %r12, -0x10(%r12)
movq $0x0, -0x8(%r12)
movb $0x0, (%r12)
movq 0x88(%rsi), %rdi
movq (%rdi), %rax
callq *(%rax)
testb %al, %al
jne 0xfb9c
movq 0x88(%r14), %rsi
movq (%rsi), %rax
leaq 0x20(%rsp), %rdi
callq *0x18(%rax)
leaq 0x80(%rsp), %rdi
leaq 0x20(%rsp), %r15
movq %r15, %rsi
callq 0xa370
movq (%r15), %rdi
leaq 0x30(%rsp), %rax
cmpq %rax, %rdi
je 0xfb9c
callq 0xa2b0
movq 0x90(%r14), %rsi
movq (%rsi), %rax
leaq 0x20(%rsp), %rdi
callq *0x18(%rax)
leaq 0x70(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
movq 0x98(%r14), %rdi
movq (%rdi), %rax
callq *(%rax)
testb %al, %al
jne 0xfc05
movq 0x98(%r14), %rsi
movq (%rsi), %rax
movq %rsp, %rdi
callq *0x18(%rax)
leaq 0x60(%rsp), %rdi
movq %rsp, %r14
movq %r14, %rsi
callq 0xa370
movq (%r14), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0xfc05
callq 0xa2b0
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x66e3a(%rip), %rdx     # 0x76a4f
movq %rsp, %rdi
movq %rdx, %rsi
callq 0xdf6a
leaq 0x50(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x66e1f(%rip), %rdx     # 0x76a4f
leaq 0x40(%rsp), %rdi
movq %rdx, %rsi
callq 0xdf6a
leaq 0x20(%rsp), %rsi
movq %rsp, %rdx
leaq 0x40(%rsp), %rcx
leaq 0x80(%rsp), %r8
leaq 0x60(%rsp), %r9
movq %rbx, %rdi
callq 0x71381
movq 0x40(%rsp), %rdi
cmpq %r13, %rdi
je 0xfc6e
callq 0xa2b0
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0xfc7c
callq 0xa2b0
movq 0x60(%rsp), %rdi
cmpq %r15, %rdi
je 0xfc8b
callq 0xa2b0
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xfc9e
callq 0xa2b0
movq 0x80(%rsp), %rdi
cmpq %r12, %rdi
je 0xfcb0
callq 0xa2b0
movq %rbx, %rax
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0xfcf1
jmp 0xfd1a
movq %rax, %rbx
movq 0x40(%rsp), %rdi
cmpq %r13, %rdi
je 0xfcdf
callq 0xa2b0
jmp 0xfcdf
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0xfcf4
callq 0xa2b0
jmp 0xfcf4
jmp 0xfcf1
movq %rax, %rbx
movq 0x60(%rsp), %rdi
cmpq %r15, %rdi
je 0xfd03
callq 0xa2b0
leaq 0x30(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0xfd1d
callq 0xa2b0
jmp 0xfd1d
jmp 0xfd1a
movq %rax, %rbx
movq 0x80(%rsp), %rdi
cmpq %r12, %rdi
je 0xfd2f
callq 0xa2b0
movq %rbx, %rdi
callq 0xa510
nop
// File: /workspace/github_cpp_makefile_star2_O1/menhits[P]phplus/src/AstNode.cpp
// Function: AstConstExpression::getString[abi:cxx11]()
string AstConstExpression::getString()
{
	string centerStr=center->getString();
	
	string rightStr;
	if (!rightIn->isVoid())
	{
		rightStr=rightIn->getString();
	}
	
	return str::makeRootUpBinaryTree(centerStr, "", "const", "", rightStr);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq 0x88(%rsi), %rsi
movq (%rsi), %rax
leaq 0x80(%rsp), %rdi
callq *0x18(%rax)
leaq 0x70(%rsp), %r15
movq %r15, -0x10(%r15)
movq $0x0, -0x8(%r15)
movb $0x0, (%r15)
movq 0x90(%r14), %rdi
movq (%rdi), %rax
callq *(%rax)
testb %al, %al
jne 0x10480
movq 0x90(%r14), %rsi
movq (%rsi), %rax
movq %rsp, %rdi
callq *0x18(%rax)
leaq 0x60(%rsp), %rdi
movq %rsp, %r14
movq %r14, %rsi
callq 0xa370
movq (%r14), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x10480
callq 0xa2b0
leaq 0x10(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x665bf(%rip), %rdx     # 0x76a4f
movq %rsp, %rdi
movq %rdx, %rsi
callq 0xdf6a
leaq 0x50(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x65df7(%rip), %rsi     # 0x762a3
leaq 0x65df5(%rip), %rdx     # 0x762a8
leaq 0x40(%rsp), %rdi
callq 0xdf6a
leaq 0x30(%rsp), %r13
movq %r13, -0x10(%r13)
leaq 0x66582(%rip), %rdx     # 0x76a4f
leaq 0x20(%rsp), %rdi
movq %rdx, %rsi
callq 0xdf6a
leaq 0x80(%rsp), %rsi
movq %rsp, %rdx
leaq 0x40(%rsp), %rcx
leaq 0x20(%rsp), %r8
leaq 0x60(%rsp), %r9
movq %rbx, %rdi
callq 0x71381
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0x1050b
callq 0xa2b0
movq 0x40(%rsp), %rdi
cmpq %r12, %rdi
je 0x1051a
callq 0xa2b0
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x10528
callq 0xa2b0
movq 0x60(%rsp), %rdi
cmpq %r15, %rdi
je 0x10537
callq 0xa2b0
leaq 0x90(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x1054d
callq 0xa2b0
movq %rbx, %rax
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x105a0
movq %rax, %rbx
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0x1057a
callq 0xa2b0
jmp 0x1057a
movq %rax, %rbx
movq 0x40(%rsp), %rdi
cmpq %r12, %rdi
je 0x1058e
callq 0xa2b0
jmp 0x1058e
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r14, %rdi
je 0x105a3
callq 0xa2b0
jmp 0x105a3
jmp 0x105a0
movq %rax, %rbx
movq 0x60(%rsp), %rdi
cmpq %r15, %rdi
je 0x105b2
callq 0xa2b0
leaq 0x90(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x105c8
callq 0xa2b0
movq %rbx, %rdi
callq 0xa510
// File: /workspace/github_cpp_makefile_star2_O1/menhits[P]phplus/src/AstNode.cpp
// Function: AstTuple::resolveAction()
void AstTuple::resolveAction()
{
	vector<Action> actions;
	
	for (int i=0; i<int(nodes.size()); i++)
	{
		nodes[i]->setInput(ns, dynamic, Void, Void);
		actions.push_back(nodes[i]->getAction());
	}
	
	action=makeTupleAction(actions);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
xorps %xmm0, %xmm0
movaps %xmm0, 0x40(%rsp)
movq $0x0, 0x50(%rsp)
movq 0x88(%rdi), %rax
movq 0x90(%rdi), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
testl %ecx, %ecx
jle 0x13fff
xorl %r14d, %r14d
leaq 0x8551f(%rip), %r15     # 0x99400
movq %rsp, %r13
leaq 0x40(%rsp), %rbp
movq 0x850b8(%rip), %r12     # 0x98fa8
movq (%rax,%r14,8), %rdi
movq 0x70(%rbx), %rax
movq %rax, 0x30(%rsp)
movq 0x78(%rbx), %rax
movq %rax, 0x38(%rsp)
testq %rax, %rax
je 0x13f1b
cmpb $0x0, (%r12)
je 0x13f17
incl 0x8(%rax)
jmp 0x13f1b
lock
incl 0x8(%rax)
movb 0x68(%rbx), %al
movq (%r15), %rdx
movq 0x8(%r15), %rcx
movq %rdx, 0x20(%rsp)
movq %rcx, 0x28(%rsp)
testq %rcx, %rcx
je 0x13f44
cmpb $0x0, (%r12)
je 0x13f40
incl 0x8(%rcx)
jmp 0x13f44
lock
incl 0x8(%rcx)
movq (%r15), %rdx
movq 0x8(%r15), %rcx
movq %rdx, 0x10(%rsp)
movq %rcx, 0x18(%rsp)
testq %rcx, %rcx
je 0x13f6a
cmpb $0x0, (%r12)
je 0x13f66
incl 0x8(%rcx)
jmp 0x13f6a
lock
incl 0x8(%rcx)
movzbl %al, %edx
leaq 0x30(%rsp), %rsi
leaq 0x20(%rsp), %rcx
leaq 0x10(%rsp), %r8
callq 0x1491e
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x13f90
callq 0xdcba
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x13f9f
callq 0xdcba
movq 0x38(%rsp), %rdi
testq %rdi, %rdi
je 0x13fae
callq 0xdcba
movq 0x88(%rbx), %rax
movq (%rax,%r14,8), %rsi
movq %r13, %rdi
callq 0x14bb8
movq %rbp, %rdi
movq %r13, %rsi
callq 0x174f8
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x13fdb
callq 0xdcba
incq %r14
movq 0x88(%rbx), %rax
movq 0x90(%rbx), %rcx
subq %rax, %rcx
shrq $0x3, %rcx
movslq %ecx, %rcx
cmpq %rcx, %r14
jl 0x13ef0
movq %rsp, %rdi
leaq 0x40(%rsp), %rsi
callq 0x695d0
movaps (%rsp), %xmm0
xorps %xmm1, %xmm1
movaps %xmm1, (%rsp)
movq 0x50(%rbx), %rdi
movups %xmm0, 0x48(%rbx)
testq %rdi, %rdi
je 0x14029
callq 0xdcba
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x14038
callq 0xdcba
leaq 0x40(%rsp), %rdi
callq 0x14d7c
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1407b
movq %rax, %rbx
movq 0x18(%rsp), %rdi
testq %rdi, %rdi
je 0x14065
callq 0xdcba
movq 0x28(%rsp), %rdi
testq %rdi, %rdi
je 0x14074
callq 0xdcba
movq 0x38(%rsp), %rdi
jmp 0x14088
movq %rax, %rbx
jmp 0x14092
movq %rax, %rbx
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x14092
callq 0xdcba
leaq 0x40(%rsp), %rdi
callq 0x14d7c
movq %rbx, %rdi
callq 0xa510
// File: /workspace/github_cpp_makefile_star2_O1/menhits[P]phplus/src/AstNode.cpp
// Function: AstTupleType::getString[abi:cxx11]()
string AstTupleType::getString()
{
	string out;
	
	out+="AstTupleType{";
	
	for (int i=0; i<int(subTypes.size()); i++)
	{
		auto type=&subTypes[i];
		
		if (type->name)
		{
			out+=type->name->getText()+": ";
		}
		
		out+=type->type->getString();
		
		if (i<int(subTypes.size())-1)
		{
			out+=", ";
		}
	}
	
	out+="}";
	
	return out;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rdi), %rax
movq %rax, 0x20(%rsp)
movq %rax, (%rdi)
movq $0x0, 0x8(%rdi)
movb $0x0, 0x10(%rdi)
leaq 0x6225b(%rip), %rsi     # 0x76598
callq 0xa560
movq 0x88(%r14), %r13
movq 0x90(%r14), %rax
subq %r13, %rax
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %eax # imm = 0xAAAAAAAB
testl %eax, %eax
jle 0x144b7
xorl %r15d, %r15d
xorl %r12d, %r12d
cmpq $0x0, (%r13,%r15)
je 0x14428
movq (%r13,%r15), %rax
leaq 0x38(%rsp), %rcx
movq %rcx, 0x28(%rsp)
movq (%rax), %rsi
movq 0x8(%rax), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rbp
movq %rbp, %rdi
callq 0xdde2
movq %rbp, %rdi
leaq 0x6793d(%rip), %rsi     # 0x7bce4
callq 0xa560
leaq 0x10(%rsp), %rsi
movq %rsi, (%rsp)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
je 0x143d2
movq %rdx, (%rsp)
movq (%rcx), %rdx
movq %rdx, 0x10(%rsp)
jmp 0x143d8
movups (%rcx), %xmm0
movups %xmm0, (%rsi)
movq 0x8(%rax), %rdx
movq %rdx, 0x8(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0xa110
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x14414
callq 0xa2b0
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
je 0x14428
callq 0xa2b0
movq 0x10(%r13,%r15), %rsi
movq (%rsi), %rax
movq %rsp, %rdi
callq *0x18(%rax)
movq (%rsp), %rsi
movq 0x8(%rsp), %rdx
movq %rbx, %rdi
leaq 0x10(%rsp), %r13
callq 0xa110
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x1445a
callq 0xa2b0
movq 0x90(%r14), %rax
subq 0x88(%r14), %rax
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %eax # imm = 0xAAAAAAAB
decl %eax
cltq
cmpq %rax, %r12
jge 0x1448a
movq %rbx, %rdi
leaq 0x65270(%rip), %rsi     # 0x796f5
callq 0xa560
incq %r12
movq 0x88(%r14), %r13
movq 0x90(%r14), %rax
subq %r13, %rax
shrq $0x3, %rax
imull $0xaaaaaaab, %eax, %eax # imm = 0xAAAAAAAB
cltq
addq $0x18, %r15
cmpq %rax, %r12
jl 0x1436b
leaq 0x65417(%rip), %rsi     # 0x798d5
movq %rbx, %rdi
callq 0xa560
movq %rbx, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1450a
jmp 0x1450a
movq %rax, %r14
jmp 0x144f7
movq %rax, %r14
movq (%rsp), %rdi
leaq 0x10(%rsp), %rax
cmpq %rax, %rdi
je 0x144f7
callq 0xa2b0
movq 0x28(%rsp), %rdi
leaq 0x38(%rsp), %rax
cmpq %rax, %rdi
jne 0x1451b
jmp 0x14520
jmp 0x1450a
movq %rax, %r14
jmp 0x14520
movq %rax, %r14
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x14520
callq 0xa2b0
movq (%rbx), %rdi
cmpq 0x20(%rsp), %rdi
je 0x1452f
callq 0xa2b0
movq %r14, %rdi
callq 0xa510
nop
// File: /workspace/github_cpp_makefile_star2_O1/menhits[P]phplus/src/../h/AstNode.h
// Function: AstNodeBase::setInput(std::shared_ptr<NamespaceData>, bool, std::shared_ptr<TypeBase>, std::shared_ptr<TypeBase>)
void setInput(Namespace nsIn, bool dynamicIn, Type left, Type right)
	{
		if (inputHasBeenSet)
		{
			throw PhplusError("tried to set input on an AST node '"+getString()+"' more then once", INTERNAL_ERROR, getToken());
		}
		
		inputHasBeenSet=true;
		
		ns=nsIn;
		dynamic=dynamicIn;
		inLeftType=left;
		inRightType=right;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x78, %rsp
movq %rdi, %r14
cmpb $0x1, 0x80(%rdi)
je 0x14997
movq %r8, %rbx
movq %rcx, %r15
movl %edx, %ebp
movb $0x1, 0x80(%r14)
movq (%rsi), %rax
movq %rax, 0x70(%r14)
leaq 0x78(%r14), %rdi
addq $0x8, %rsi
callq 0xde72
movb %bpl, 0x68(%r14)
movq (%r15), %rax
movq %rax, 0x28(%r14)
leaq 0x30(%r14), %rdi
addq $0x8, %r15
movq %r15, %rsi
callq 0xde72
movq (%rbx), %rax
movq %rax, 0x38(%r14)
addq $0x40, %r14
addq $0x8, %rbx
movq %r14, %rdi
movq %rbx, %rsi
addq $0x78, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xde72
movl $0x38, %edi
callq 0xa1b0
movq %rax, %rbx
movq (%r14), %rax
leaq 0x38(%rsp), %rdi
movq %r14, %rsi
callq *0x18(%rax)
leaq 0x61bed(%rip), %rsi     # 0x765a6
leaq 0x58(%rsp), %rdi
leaq 0x38(%rsp), %rdx
callq 0x1562b
leaq 0x61bfb(%rip), %rsi     # 0x765ca
leaq 0x58(%rsp), %rdi
callq 0xa560
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
movq (%rax), %rdx
movq %rax, %rcx
addq $0x10, %rcx
cmpq %rcx, %rdx
jne 0x149fa
movups (%rcx), %xmm0
movups %xmm0, (%r15)
jmp 0x14a07
movq %rdx, 0x18(%rsp)
movq (%rcx), %rdx
movq %rdx, 0x28(%rsp)
movq 0x8(%rax), %rdx
movq %rdx, 0x20(%rsp)
movq %rcx, (%rax)
movq $0x0, 0x8(%rax)
movb $0x0, 0x10(%rax)
movq (%r14), %rax
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq *0x38(%rax)
movb $0x1, %bpl
leaq 0x18(%rsp), %rsi
leaq 0x8(%rsp), %rcx
movq %rbx, %rdi
movl $0x3, %edx
callq 0x200e4
xorl %ebp, %ebp
leaq 0x81be8(%rip), %rsi     # 0x96638
leaq -0x15f(%rip), %rdx      # 0x148f8
movq %rbx, %rdi
callq 0xa4f0
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x14a79
callq 0xdcba
jmp 0x14a79
movq %rax, %r14
movb $0x1, %bpl
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x14a90
callq 0xa2b0
jmp 0x14a90
movq %rax, %r14
movb $0x1, %bpl
leaq 0x68(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x14aab
callq 0xa2b0
jmp 0x14aab
movq %rax, %r14
movb $0x1, %bpl
leaq 0x48(%rsp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x14ac6
callq 0xa2b0
jmp 0x14ac6
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x14ad3
movq %rbx, %rdi
callq 0xa240
movq %r14, %rdi
callq 0xa510
nop
// File: /workspace/github_cpp_makefile_star2_O1/menhits[P]phplus/src/../h/AstNode.h
// Function: AstNodeBase::getAction()
Action getAction()
	{
		if (!action)
		{
			if (!ns)
			{
				throw PhplusError("tried to get action from AST node when input had not been set", INTERNAL_ERROR, getToken());
			}
			
			resolveAction();
			
			if (!nameHint.empty())
				action->nameHint=nameHint;
		}
		
		return action;
	}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rsi, %r14
movq %rdi, %rbx
cmpq $0x0, 0x48(%rsi)
jne 0x14bf7
cmpq $0x0, 0x70(%r14)
je 0x14c2e
movq (%r14), %rax
movq %r14, %rdi
callq *0x50(%rax)
cmpq $0x0, 0x10(%r14)
je 0x14bf7
leaq 0x8(%r14), %rsi
movq 0x48(%r14), %rdi
addq $0x8, %rdi
callq 0xa1d0
movq 0x48(%r14), %rax
movq %rax, (%rbx)
movq 0x50(%r14), %rax
movq %rax, 0x8(%rbx)
testq %rax, %rax
je 0x14c20
movq 0x84396(%rip), %rcx     # 0x98fa8
cmpb $0x0, (%rcx)
je 0x14c1c
incl 0x8(%rax)
jmp 0x14c20
lock
incl 0x8(%rax)
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x38, %edi
callq 0xa1b0
movq %rax, %rbx
leaq 0x28(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x619c2(%rip), %rsi     # 0x7660d
leaq 0x619f8(%rip), %rdx     # 0x7664a
leaq 0x18(%rsp), %rdi
callq 0xdf6a
movq (%r14), %rax
leaq 0x8(%rsp), %rdi
movq %r14, %rsi
callq *0x38(%rax)
movb $0x1, %bpl
leaq 0x18(%rsp), %rsi
leaq 0x8(%rsp), %rcx
movq %rbx, %rdi
movl $0x3, %edx
callq 0x200e4
xorl %ebp, %ebp
leaq 0x819ab(%rip), %rsi     # 0x96638
leaq -0x39c(%rip), %rdx      # 0x148f8
movq %rbx, %rdi
callq 0xa4f0
movq %rax, %r14
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x14cb6
callq 0xdcba
jmp 0x14cb6
movq %rax, %r14
movb $0x1, %bpl
movq 0x18(%rsp), %rdi
cmpq %r15, %rdi
je 0x14ccd
callq 0xa2b0
jmp 0x14ccd
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x14cda
movq %rbx, %rdi
callq 0xa240
movq %r14, %rdi
callq 0xa510