LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/navrajsaini[P]PL_Compiler_design_project/administration.cpp
// Function: Admin::Admin(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Scanner&)
Admin::Admin(string inFile, string outFile, Scanner &sn)
{
   output.open(outFile.c_str());
   output.close();
   in = inFile;
   out = outFile;
   //scnr = &scan;
   view.setName(in, out);
   view.symbolTable.loadResvd();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %r15
movw $0x101, (%rdi)          # imm = 0x101
movb $0x0, 0x2(%rdi)
addq $0x8, %rdi
movq %rdi, -0x58(%rbp)
callq 0x21d0
leaq 0x210(%r15), %r14
movq %r14, %rdi
callq 0x22b0
leaq 0x410(%r15), %rbx
movq %rbx, %rdi
callq 0x22b0
movq %rbx, -0x50(%rbp)
leaq 0x620(%r15), %rax
movq %rax, 0x610(%r15)
andq $0x0, 0x618(%r15)
xorl %eax, %eax
movb %al, 0x620(%r15)
leaq 0x640(%r15), %rcx
movq %rcx, 0x630(%r15)
andq $0x0, 0x638(%r15)
leaq 0x610(%r15), %rcx
movq %rcx, -0x40(%rbp)
leaq 0x630(%r15), %rcx
movq %rcx, -0x38(%rbp)
movb %al, 0x640(%r15)
leaq 0x650(%r15), %rdi
leaq 0x7157(%rip), %rsi      # 0xf16b
leaq -0x29(%rbp), %rdx
movq %rdi, -0x48(%rbp)
callq 0x20a0
leaq 0x670(%r15), %rbx
movq %rbx, %rdi
callq 0x86ba
movq (%r12), %rsi
pushq $0x10
popq %rdx
movq %r14, %rdi
callq 0x2030
movq %r14, %rdi
callq 0x2250
movq -0x40(%rbp), %rdi
movq %r13, %rsi
callq 0x2110
movq -0x38(%rbp), %rdi
movq %r12, %rsi
callq 0x2110
leaq -0x98(%rbp), %rdi
movq -0x40(%rbp), %rsi
callq 0x2240
leaq -0x78(%rbp), %rdi
movq -0x38(%rbp), %rsi
callq 0x2240
leaq -0x98(%rbp), %rsi
leaq -0x78(%rbp), %rdx
movq %rbx, %rdi
callq 0x8a82
leaq -0x78(%rbp), %rdi
callq 0x20d0
leaq -0x98(%rbp), %rdi
callq 0x20d0
addq $0x678, %r15            # imm = 0x678
movq %r15, %rdi
callq 0x3bc0
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
leaq -0x78(%rbp), %rdi
callq 0x20d0
jmp 0x80d3
movq %rax, %r15
leaq -0x98(%rbp), %rdi
callq 0x20d0
jmp 0x80f8
movq %rax, %r15
jmp 0x8100
movq %rax, %r15
jmp 0x8109
movq %rax, %r15
jmp 0x8124
movq %rax, %r15
jmp 0x812c
movq %rax, %r15
movq %rbx, %rdi
callq 0x37e2
movq -0x48(%rbp), %rdi
callq 0x20d0
movq -0x38(%rbp), %rdi
callq 0x20d0
movq -0x40(%rbp), %rdi
callq 0x20d0
movq -0x50(%rbp), %rdi
callq 0x2270
movq %r14, %rdi
callq 0x2270
movq -0x58(%rbp), %rdi
callq 0x2050
movq %r15, %rdi
callq 0x22e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/navrajsaini[P]PL_Compiler_design_project/administration.cpp
// Function: Admin::scan()
int Admin::scan()
{
   char now[256];
   input.open(in.c_str());
   do{
      //clearing the array of characters
      for(int j=0;j<255;j++)
	 now[j]=' ';  
      input.getline(now,256);   
      view.tokenLine(now, 256);
      view.LN++;
      lineNo++;
   }while(!input.eof());
/*
  for debuging purposes
  view.symbolTable.printTable();
  
*/
input.close();
   return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movq %rdi, %r14
leaq 0x8(%rdi), %rbx
movq 0x610(%rdi), %rsi
pushq $0x8
popq %rdx
movq %rbx, %rdi
callq 0x2140
leaq 0x670(%r14), %r15
xorl %eax, %eax
leaq -0x120(%rbp), %r12
cmpq $0xff, %rax
je 0x81cc
movb $0x20, -0x120(%rbp,%rax)
incq %rax
jmp 0x81b7
movl $0x100, %edx            # imm = 0x100
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2080
movq %r15, %rdi
movq %r12, %rsi
movl $0x100, %edx            # imm = 0x100
callq 0x8c26
incl 0x1298(%r14)
incl 0x1ce0(%r14)
movq 0x8(%r14), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x28(%r14,%rax)
movl $0x0, %eax
je 0x81b7
movq %rbx, %rdi
callq 0x2040
pushq $0x1
popq %rax
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/navrajsaini[P]PL_Compiler_design_project/administration.cpp
// Function: Admin::emit1(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Admin::emit1(string OP)
{
   outsource.open(codeGen, ios::app);
   
   if (emitting)
   {
      outsource << OP << endl;
   }
   outsource.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
leaq 0x410(%rdi), %rbx
leaq 0x650(%rdi), %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x20e0
cmpb $0x1, (%r15)
jne 0x85b4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x2180
movq %rax, %rdi
callq 0x20f0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2250
// File: /workspace/github_cpp_makefile_star2_O2/navrajsaini[P]PL_Compiler_design_project/administration.cpp
// Function: Admin::emit2(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
void Admin::emit2 (string OP, int arg1)
{
   outsource.open(codeGen, ios::app);
   if (emitting)
   {
      outsource << OP << endl << arg1 << endl;
   }
   outsource.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
leaq 0x410(%rdi), %rbx
leaq 0x650(%rdi), %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x20e0
cmpb $0x1, (%r12)
jne 0x8620
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2180
movq %rax, %rdi
callq 0x20f0
movq %rax, %rdi
movl %r14d, %esi
callq 0x22c0
movq %rax, %rdi
callq 0x20f0
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2250
// File: /workspace/github_cpp_makefile_star2_O2/navrajsaini[P]PL_Compiler_design_project/administration.cpp
// Function: Admin::emit3(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int)
void Admin::emit3 (string OP, int arg1, int arg2)
{
   outsource.open(codeGen, ios::app);
   if (emitting)
   {
      outsource << OP << endl << arg1 << endl << arg2 << endl;
   }
   outsource.close();
   
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r14d
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %r13
leaq 0x410(%rdi), %rbx
leaq 0x650(%rdi), %rsi
pushq $0x1
popq %rdx
movq %rbx, %rdi
callq 0x20e0
cmpb $0x1, (%r13)
jne 0x86a3
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2180
movq %rax, %rdi
callq 0x20f0
movq %rax, %rdi
movl %r15d, %esi
callq 0x22c0
movq %rax, %rdi
callq 0x20f0
movq %rax, %rdi
movl %r14d, %esi
callq 0x22c0
movq %rax, %rdi
callq 0x20f0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2250
nop
// File: /workspace/github_cpp_makefile_star2_O2/navrajsaini[P]PL_Compiler_design_project/scanner.cpp
// Function: Scanner::Scanner(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Scanner::Scanner(string inCodeName, string outCodeName)//, Symtable &symbolTable)
{
   setName(inCodeName, outCodeName);
   symbolTable.loadResvd();
   LN=1;
   TN=1;
   while(TN<255)
   {
      lineToke[TN][0] = 0;
      lineToke[TN][1] = 0;
      lineToke[TN][2] = 0;
      TN++;
   }
   TN=1;
	 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
movq %r14, %rdi
callq 0x87d0
movl $0x1, 0xc2c(%rbx)
leaq 0xc30(%rbx), %r15
movq %r15, %rdi
callq 0x22b0
leaq 0xe40(%rbx), %rax
movq %rax, 0xe30(%rbx)
andq $0x0, 0xe38(%rbx)
xorl %eax, %eax
movb %al, 0xe40(%rbx)
leaq 0xe60(%rbx), %rcx
movq %rcx, 0xe50(%rbx)
andq $0x0, 0xe58(%rbx)
movb %al, 0xe60(%rbx)
leaq -0x68(%rbp), %rdi
movq %r13, %rsi
callq 0x2240
leaq -0x48(%rbp), %rdi
movq %r12, %rsi
callq 0x2240
leaq -0x68(%rbp), %rsi
leaq -0x48(%rbp), %rdx
movq %rbx, %rdi
callq 0x8a82
leaq -0x48(%rbp), %rdi
callq 0x20d0
leaq -0x68(%rbp), %rdi
callq 0x20d0
movq %r14, %rdi
callq 0x3bc0
movl $0x1, 0xc28(%rbx)
leaq 0x28(%rbx), %rax
pushq $0x1
popq %rcx
movl %ecx, 0xc2c(%rbx)
cmpl $0xfe, %ecx
jg 0x8a0e
movslq %ecx, %rcx
imulq $0xc, %rcx, %rcx
andq $0x0, (%rax,%rcx)
movslq 0xc2c(%rbx), %rcx
imulq $0xc, %rcx, %rdx
andl $0x0, 0x8(%rax,%rdx)
incl %ecx
jmp 0x89e0
movl $0x1, 0xc2c(%rbx)
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
leaq -0x48(%rbp), %rdi
callq 0x20d0
jmp 0x8a38
movq %rax, %r12
leaq -0x68(%rbp), %rdi
callq 0x20d0
jmp 0x8a4b
movq %rax, %r12
jmp 0x8a71
movq %rax, %r12
leaq 0xe30(%rbx), %r13
addq $0xe50, %rbx            # imm = 0xE50
movq %rbx, %rdi
callq 0x20d0
movq %r13, %rdi
callq 0x20d0
movq %r15, %rdi
callq 0x2270
movq %r14, %rdi
callq 0x3822
movq %r12, %rdi
callq 0x22e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/navrajsaini[P]PL_Compiler_design_project/scanner.cpp
// Function: Scanner::inc(int)
void Scanner::inc(int SV)
{
lineToke[TN][1] = SV;
lineToke[TN][0] = LN;
lineToke[TN][2] = 0;
//cout<<TN
TN++;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq 0xc2c(%rdi), %rax
imulq $0xc, %rax, %rax
movl %esi, 0x2c(%rdi,%rax)
movl 0xc28(%rdi), %eax
movslq 0xc2c(%rdi), %rcx
imulq $0xc, %rcx, %rdx
movl %eax, 0x28(%rdi,%rdx)
andl $0x0, 0x30(%rdi,%rdx)
leal 0x1(%rcx), %eax
movl %eax, 0xc2c(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/navrajsaini[P]PL_Compiler_design_project/scanner.cpp
// Function: Scanner::getToken(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int Scanner::getToken(string token)
{
   int storeVal;
   
   storeVal = symbolTable.insert(token);

   inc(storeVal);

   
   return storeVal;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
leaq -0x38(%rbp), %r15
movq %r15, %rdi
callq 0x2240
movq %r14, %rdi
movq %r15, %rsi
callq 0x40c8
movl %eax, %r14d
leaq -0x38(%rbp), %rdi
callq 0x20d0
movq %rbx, %rdi
movl %r14d, %esi
callq 0x8b26
movl %r14d, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O2/navrajsaini[P]PL_Compiler_design_project/scanner.cpp
// Function: Scanner::numericVAl(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int Scanner::numericVAl(string s)
{
   //cout<<s<<", "<<s.size()<<endl;
   int sSize = s.size()-1;
   int total = 0;
   int inc = 0;
   for(int i = sSize; 0 <= i; i--)
   {
      //cout<<inc<<", "<<sSize;
      char a = s[i];
      switch(a)
      {
	 case '1':
	    total = total + (1 * pow(10, inc));
	    break;
	 case '2':
	    total = total + (2 * pow(10, inc));
	    break;
	 case '3':
	    total = total + (3 * pow(10, inc));
	    break;	    
	 case '4':
	    total = total + (4 * pow(10, inc));
	    break;			 
	 case '5':
	    total = total + (5 * pow(10, inc));
	    break;	    
	 case '6':
	    total = total + (6 * pow(10, inc));
	    break;			 
	 case '7':
	    total = total + (7 * pow(10, inc));
	    break;	    
	 case '8':
	    total = total + (8 * pow(10, inc));
	    break;	    
	 case '9':
	    total = total + (9 * pow(10, inc));
	    break;	    
	 case '0':
	    total=total;	    
	 default:
	    break;
      }
      //cout<<", "<<total<<endl; 
      inc++;
   }
   //cout<<total<<endl;
   return total;  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movl 0x8(%rsi), %r14d
decq %r14
xorl %r15d, %r15d
leaq 0x6461(%rip), %r12      # 0xf4c0
xorl %eax, %eax
testl %r14d, %r14d
js 0x917b
movl %r14d, %ecx
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
movq (%rbx), %rdx
movzbl (%rdx,%rcx), %ecx
addl $-0x31, %ecx
cmpl $0x8, %ecx
ja 0x9170
movslq (%r12,%rcx,4), %rcx
addq %r12, %rcx
cvtsi2sd %eax, %xmm0
movsd %xmm0, -0x28(%rbp)
cvtsi2sd %r15d, %xmm1
jmpq *%rcx
movsd 0x63db(%rip), %xmm0     # 0xf480
callq 0x22d0
jmp 0x9167
movsd 0x63c9(%rip), %xmm0     # 0xf480
callq 0x22d0
mulsd 0x63e4(%rip), %xmm0     # 0xf4a8
jmp 0x9167
movsd 0x63af(%rip), %xmm0     # 0xf480
callq 0x22d0
mulsd 0x63da(%rip), %xmm0     # 0xf4b8
jmp 0x9167
movsd 0x6395(%rip), %xmm0     # 0xf480
callq 0x22d0
mulsd 0x63b8(%rip), %xmm0     # 0xf4b0
jmp 0x9167
movsd 0x637e(%rip), %xmm0     # 0xf480
callq 0x22d0
mulsd 0x6381(%rip), %xmm0     # 0xf490
jmp 0x9167
movsd 0x6367(%rip), %xmm0     # 0xf480
callq 0x22d0
addsd %xmm0, %xmm0
jmp 0x9167
movsd 0x6354(%rip), %xmm0     # 0xf480
callq 0x22d0
mulsd 0x6367(%rip), %xmm0     # 0xf4a0
jmp 0x9167
movsd 0x633d(%rip), %xmm0     # 0xf480
callq 0x22d0
mulsd 0x6348(%rip), %xmm0     # 0xf498
jmp 0x9167
movsd 0x6326(%rip), %xmm0     # 0xf480
callq 0x22d0
mulsd 0x6321(%rip), %xmm0     # 0xf488
addsd -0x28(%rbp), %xmm0
cvttsd2si %xmm0, %eax
incl %r15d
decq %r14
jmp 0x9061
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::eraseList()
void Parse::eraseList()
{
   eraseVar();
   for(int i = 0; i <= 10; i++)
   {
      varListIndex[i] = 0;
      varListVal[i] = 0;
      size[i] = 1;
   }
   listDepth = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
andl $0x0, 0x4ddc(%rdi)
movabsq $0x400000002, %rax      # imm = 0x400000002
movq %rax, 0x4dd4(%rdi)
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %rax, 0x4de4(%rdi)
xorl %eax, %eax
cmpq $0xb, %rax
je 0x94c5
andl $0x0, 0x4d38(%rdi,%rax,4)
andl $0x0, 0x4d60(%rdi,%rax,4)
movl $0x1, 0x4de8(%rdi,%rax,4)
incq %rax
jmp 0x949f
andl $0x0, 0x4d88(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::match()
void Parse::match()
{
   NS=LHS;
   LHS=token[tokeNum];
   tokeNum++;
   //test line
   //cout<<"token '"<<LHS<<"' is the '"<<tokeNum-1<<"' token parsed"<<endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x5050(%rdi), %r14
addq $0x5070, %rdi           # imm = 0x5070
movq %r14, %rsi
callq 0x2110
movslq 0x2028(%rbx), %rsi
shlq $0x5, %rsi
addq %rbx, %rsi
movq %r14, %rdi
callq 0x2110
incl 0x2028(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::parseNow()
void Parse::parseNow()
{  //test line
   //printToken();
   //o();
   //LHS = token[tokeNum];
   for(int i = 0; i<10; i++)
      valLength[i] = 0;
   NS=LHS;
   //cout<<endl<<LHS<<endl;
   Program();
   for(int i = 0; i<10; i++)
      valLength[i] = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1c71, %eax           # imm = 0x1C71
cmpq $0x1c7b, %rax           # imm = 0x1C7B
je 0x9583
andl $0x0, (%rbx,%rax,4)
incq %rax
jmp 0x9572
leaq 0x5050(%rbx), %rsi
leaq 0x5070(%rbx), %rdi
callq 0x2110
movq %rbx, %rdi
callq 0x9d50
xorl %eax, %eax
cmpq $0xa, %rax
je 0x95b3
andl $0x0, 0x71c4(%rbx,%rax,4)
incq %rax
jmp 0x95a0
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::errorReport()
void Parse::errorReport()
{
   gen.emitting = 0;
   if(isErr == 0)
   {
      isErr = 1;
      cout<<endl<<"Total tokens parsed: '"<<tokeNum;
      cout<<"' There was an error on Line Number: '";
      cout<<ln[tokeNum][0]<<"'"<<endl;
      cout<<"This, has the last function to be called acronymed as: '";
      cout<<where<<"'"<<endl;
      cout<<"The token of issue is: '"<<LHS;
      cout<<"' with a hashval of: '"<<ln[tokeNum][1]<<"'"<<endl;
      cout<<"The token val of: '"<<ln[tokeNum][2]<<"'"<<endl;
      stopType = 1;
      ctd = 0;
   }
}

// Assembly:
movb $0x0, 0x50c0(%rdi)
cmpb $0x0, 0x50b8(%rdi)
je 0x9683
retq
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb $0x1, 0x50b8(%rdi)
movq 0xb92a(%rip), %r14      # 0x14fc8
movq %r14, %rdi
callq 0x20f0
leaq 0x5e99(%rip), %rsi      # 0xf546
movq %rax, %rdi
callq 0x21a0
movl 0x2028(%rbx), %esi
movq %rax, %rdi
callq 0x22c0
leaq 0x5e93(%rip), %rsi      # 0xf55d
movq %r14, %rdi
callq 0x21a0
movslq 0x2028(%rbx), %rax
imulq $0xc, %rax, %rax
movl 0x2030(%rbx,%rax), %esi
movq %r14, %rdi
callq 0x22c0
leaq 0x5e68(%rip), %r15      # 0xf55b
movq %rax, %rdi
movq %r15, %rsi
callq 0x21a0
movq %rax, %rdi
callq 0x20f0
leaq 0x5e77(%rip), %rsi      # 0xf584
movq %r14, %rdi
callq 0x21a0
leaq 0x5098(%rbx), %rsi
movq %r14, %rdi
callq 0x2180
movq %rax, %rdi
movq %r15, %rsi
callq 0x21a0
movq %rax, %rdi
callq 0x20f0
leaq 0x5e7f(%rip), %rsi      # 0xf5bd
movq %r14, %rdi
callq 0x21a0
leaq 0x5050(%rbx), %rsi
movq %rax, %rdi
callq 0x2180
leaq 0x5e7a(%rip), %rsi      # 0xf5d6
movq %r14, %rdi
callq 0x21a0
movslq 0x2028(%rbx), %rcx
imulq $0xc, %rcx, %rcx
movl 0x2034(%rbx,%rcx), %esi
movq %rax, %rdi
callq 0x22c0
movq %rax, %rdi
movq %r15, %rsi
callq 0x21a0
movq %rax, %rdi
callq 0x20f0
leaq 0x5e55(%rip), %rsi      # 0xf5ed
movq %r14, %rdi
callq 0x21a0
movslq 0x2028(%rbx), %rcx
imulq $0xc, %rcx, %rcx
movl 0x2038(%rbx,%rcx), %esi
movq %rax, %rdi
callq 0x22c0
movq %rax, %rdi
movq %r15, %rsi
callq 0x21a0
movq %rax, %rdi
callq 0x20f0
movw $0x100, 0x2c30(%rbx)    # imm = 0x100
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::scopeError(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Parse::scopeError(string s)
{
   gen.emitting = 0;
   if(stopType == 0)
   {
      isErr = 1;
      cout<<s<<" with index: "<<ln[tokeNum][1]<<" at line:  "<<ln[tokeNum][0]<<" with token : "<<NS<<endl;
      ctd = 0;
   }
}

// Assembly:
movb $0x0, 0x50c0(%rdi)
cmpb $0x0, 0x2c31(%rdi)
je 0x98a1
retq
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movb $0x1, 0x50b8(%rdi)
movq 0xb710(%rip), %rdi      # 0x14fc8
callq 0x2180
leaq 0x5d44(%rip), %rsi      # 0xf608
movq %rax, %rdi
callq 0x21a0
movslq 0x2028(%rbx), %rcx
imulq $0xc, %rcx, %rcx
movl 0x2034(%rbx,%rcx), %esi
movq %rax, %rdi
callq 0x22c0
leaq 0x5d29(%rip), %rsi      # 0xf616
movq %rax, %rdi
callq 0x21a0
movslq 0x2028(%rbx), %rcx
imulq $0xc, %rcx, %rcx
movl 0x2030(%rbx,%rcx), %esi
movq %rax, %rdi
callq 0x22c0
leaq 0x5d0c(%rip), %rsi      # 0xf622
movq %rax, %rdi
callq 0x21a0
leaq 0x5070(%rbx), %rsi
movq %rax, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20f0
movb $0x0, 0x2c30(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::eraseVar()
void Parse::eraseVar()
{
   index = 0;
   eKind = UNDEFINED;
   eType = UNIVERSAL;
   checkVal = 0;
   size[0] = 1;
   listDepth = 0;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
andl $0x0, 0x4ddc(%rdi)
movabsq $0x400000002, %rax      # imm = 0x400000002
movq %rax, 0x4dd4(%rdi)
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %rax, 0x4de4(%rdi)
andl $0x0, 0x4d88(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::checkDefConst()
bool Parse::checkDefConst()
{//printScopeType(true);
   if (!bTable.define(index, eKind, eType, size[0], checkVal, levelOfCurrentBlock[currentLevel], 0))//proc label and displacement
   {
      eraseVar();
      return false;
   }
   //cout<<endl<<"'"<<levelOfCurrentBlock[currentLevel]<<"'"<<currentLevel<<"'"<<endl;
   levelOfCurrentBlock[currentLevel]++;
   eraseVar();
   return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x4c38, %rdi           # imm = 0x4C38
movl 0x4ddc(%rbx), %esi
movl 0x4dd4(%rbx), %ecx
movl 0x4dd8(%rbx), %edx
movl 0x4de8(%rbx), %r8d
movl 0x4de4(%rbx), %r9d
movslq 0x7224(%rbx), %rax
movl 0x71fc(%rbx,%rax,4), %eax
pushq $0x0
pushq %rax
callq 0xc83e
popq %rcx
popq %rdx
testb %al, %al
je 0x99d4
movslq 0x7224(%rbx), %rcx
incl 0x71fc(%rbx,%rcx,4)
andl $0x0, 0x4ddc(%rbx)
movabsq $0x400000002, %rcx      # imm = 0x400000002
movq %rcx, 0x4dd4(%rbx)
movabsq $0x100000000, %rcx      # imm = 0x100000000
movq %rcx, 0x4de4(%rbx)
andl $0x0, 0x4d88(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::checkDef(int)
bool Parse::checkDef(int procLabel)
{//printScopeType(true);
   if (!bTable.define(index, eKind, eType, 0, 0, 0, procLabel))
   {
      eraseVar();
      return false;
   }
   eraseVar();
   return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
addq $0x4c38, %rdi           # imm = 0x4C38
movl 0x4ddc(%rbx), %eax
movl 0x4dd4(%rbx), %ecx
movl 0x4dd8(%rbx), %edx
andl $0x0, (%rsp)
movl %esi, 0x8(%rsp)
movl %eax, %esi
xorl %r8d, %r8d
xorl %r9d, %r9d
callq 0xc83e
andl $0x0, 0x4ddc(%rbx)
movabsq $0x400000002, %rcx      # imm = 0x400000002
movq %rcx, 0x4dd4(%rbx)
movabsq $0x100000000, %rcx      # imm = 0x100000000
movq %rcx, 0x4de4(%rbx)
andl $0x0, 0x4d88(%rbx)
addq $0x18, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::checkDefList()
bool Parse::checkDefList()
{//printScopeType(false);
   
   for(int limit = 0; limit < listDepth; limit++)
   {
      
      if (!bTable.define(varListIndex[limit], eKind, eType, size[limit], varListVal[limit],levelOfCurrentBlock[currentLevel], 0))//incriment displacment by 1
      {
	 eraseList();
	 return false;
      }
      //cout<<endl<<"'"<<levelOfCurrentBlock[currentLevel]<<"'"<<currentLevel<<"'"<<endl;
      levelOfCurrentBlock[currentLevel]++;
   }
   eraseList();
   return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdi, %rbx
leaq 0x4c38(%rdi), %r14
xorl %r15d, %r15d
movslq 0x4d88(%rbx), %r12
cmpq %r12, %r15
jge 0x9af8
movl 0x4dd4(%rbx), %ecx
movl 0x4dd8(%rbx), %edx
movl 0x4de8(%rbx,%r15,4), %r8d
movl 0x4d38(%rbx,%r15,4), %esi
movl 0x4d60(%rbx,%r15,4), %r9d
movslq 0x7224(%rbx), %rax
movl 0x71fc(%rbx,%rax,4), %eax
movq %r14, %rdi
pushq $0x0
pushq %rax
callq 0xc83e
popq %rcx
popq %rdx
testb %al, %al
je 0x9af8
movslq 0x7224(%rbx), %rax
incl 0x71fc(%rbx,%rax,4)
incq %r15
jmp 0x9a96
cmpq %r12, %r15
setge %r14b
movq %rbx, %rdi
callq 0x9470
movl %r14d, %eax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::printScopeType(bool)
void Parse::printScopeType(bool y)
{
   if(y)
      cout<<"index: "<<index<<" "<<NS<<endl<<LHS<<"  "<<ln[tokeNum][1]<<endl;
   if(!y)
      cout<<"indexAc: "<<varListIndex[listDepth-1]<<" "<<endl<<LHS<<"  "<<ln[tokeNum][1]<<endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movq 0xb4a4(%rip), %rdi      # 0x14fc8
testl %esi, %esi
je 0x9b62
leaq 0x5dbd(%rip), %rsi      # 0xf8ec
callq 0x21a0
movl 0x4ddc(%rbx), %esi
movq %rax, %rdi
callq 0x22c0
leaq 0x5db4(%rip), %rsi      # 0xf8fd
movq %rax, %rdi
callq 0x21a0
leaq 0x5070(%rbx), %rsi
movq %rax, %rdi
callq 0x2180
jmp 0x9b93
leaq 0x5ac8(%rip), %rsi      # 0xf631
callq 0x21a0
movslq 0x4d88(%rbx), %rcx
movl 0x4d34(%rbx,%rcx,4), %esi
movq %rax, %rdi
callq 0x22c0
leaq 0x5d72(%rip), %rsi      # 0xf8fd
movq %rax, %rdi
callq 0x21a0
movq %rax, %rdi
callq 0x20f0
leaq 0x5050(%rbx), %rsi
movq %rax, %rdi
callq 0x2180
leaq 0x5d4b(%rip), %rsi      # 0xf8fc
movq %rax, %rdi
callq 0x21a0
movslq 0x2028(%rbx), %rcx
imulq $0xc, %rcx, %rcx
movl 0x2034(%rbx,%rcx), %esi
movq %rax, %rdi
callq 0x22c0
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x20f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::o()
void Parse::o()
{ for(int i=1;token[i]!=".";i++)
   {
      cout<<"ln["<<i<<"][0]: "<<ln[i][0]<<endl;
      cout<<"ln["<<i<<"][1]: "<<ln[i][1]<<endl;
      cout<<"ln["<<i<<"][2]: "<<ln[i][2]<<endl;
      cout<<"token["<<i<<"]: "<<token[i]<<endl<<endl;
   }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x2044(%rdi), %r15
addq $0x20, %rbx
pushq $0x1
popq %r14
movq 0xb3bf(%rip), %r12      # 0x14fc8
leaq 0x5a2b(%rip), %r13      # 0xf63b
movq %rbx, %rdi
leaq 0x5de5(%rip), %rsi      # 0xf9ff
callq 0x7a38
testb %al, %al
je 0x9d25
movq %r12, %rdi
movq %r13, %rsi
callq 0x21a0
movq %rax, %rdi
movl %r14d, %esi
callq 0x22c0
movq %rax, %rdi
leaq 0x59f8(%rip), %rsi      # 0xf63f
callq 0x21a0
movl -0x8(%r15), %esi
movq %rax, %rdi
callq 0x22c0
movq %rax, %rdi
callq 0x20f0
movq %r12, %rdi
movq %r13, %rsi
callq 0x21a0
movq %rax, %rdi
movl %r14d, %esi
callq 0x22c0
movq %rax, %rdi
leaq 0x59c6(%rip), %rsi      # 0xf646
callq 0x21a0
movl -0x4(%r15), %esi
movq %rax, %rdi
callq 0x22c0
movq %rax, %rdi
callq 0x20f0
movq %r12, %rdi
movq %r13, %rsi
callq 0x21a0
movq %rax, %rdi
movl %r14d, %esi
callq 0x22c0
movq %rax, %rdi
leaq 0x5994(%rip), %rsi      # 0xf64d
callq 0x21a0
movl (%r15), %esi
movq %rax, %rdi
callq 0x22c0
movq %rax, %rdi
callq 0x20f0
movq %r12, %rdi
leaq 0x5979(%rip), %rsi      # 0xf654
callq 0x21a0
movq %rax, %rdi
movl %r14d, %esi
callq 0x22c0
movq %rax, %rdi
leaq 0x594d(%rip), %rsi      # 0xf642
callq 0x21a0
movq %rax, %rdi
movq %rbx, %rsi
callq 0x2180
movq %rax, %rdi
callq 0x20f0
movq %rax, %rdi
callq 0x20f0
addq $0xc, %r15
addq $0x20, %rbx
incl %r14d
jmp 0x9c10
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::Program()
void Parse::Program()
{where="P";check();
   if(LHS=="begin")     
   {      
      //create a new block for scope/type
      if(!bTable.newBlock())
	 scopeError("Exceded Block limit");
      //---
      varLabel = newLabel();
      startLabel = newLabel();
      gen.emit3("PROG", varLabel, startLabel);
      //***   
      //call Block    
      Block();     
      //pop block
      printPop();
      bTable.endBlock();
      //---
      if(LHS==".")
      {
	 where="P";check();
	 cout<<"YOU SUCCESSFULY PARSED, CONGRATS!!!!"<<endl;
	 valLength[valLenPtr] = 0;
	 
      }else
	 errorReport();
      //
      gen.emit1("ENDPROG");     
      //***

   }else
      errorReport();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
leaq 0x5098(%rdi), %r14
leaq 0x593a(%rip), %rsi      # 0xf6ac
movq %r14, %rdi
callq 0x2310
movq %rbx, %rdi
callq 0x97e2
leaq 0x5050(%rbx), %r15
leaq 0x559c(%rip), %rsi      # 0xf32c
movq %r15, %rdi
callq 0x7926
testb %al, %al
je 0x9ead
leaq 0x4c38(%rbx), %r12
movq %r12, %rdi
callq 0xc95c
testb %al, %al
jne 0x9de5
leaq 0x58a1(%rip), %rsi      # 0xf65b
leaq -0x90(%rbp), %rdi
leaq -0x29(%rbp), %rdx
callq 0x20a0
leaq -0x90(%rbp), %rsi
movq %rbx, %rdi
callq 0x9890
leaq -0x90(%rbp), %rdi
callq 0x20d0
movl 0x71b0(%rbx), %eax
leal 0x1(%rax), %ecx
movl %ecx, 0x71bc(%rbx)
addl $0x2, %eax
movl %eax, 0x71b0(%rbx)
movl %eax, 0x71c0(%rbx)
leaq 0x588d(%rip), %rsi      # 0xf697
leaq -0x70(%rbp), %rdi
leaq -0x29(%rbp), %rdx
callq 0x20a0
leaq 0x50c0(%rbx), %r13
movl 0x71bc(%rbx), %edx
movl 0x71c0(%rbx), %ecx
leaq -0x70(%rbp), %rsi
movq %r13, %rdi
callq 0x8630
leaq -0x70(%rbp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x9f4a
movq %rbx, %rdi
callq 0x9d34
movq %r12, %rdi
callq 0xc97c
leaq 0x5ba1(%rip), %rsi      # 0xf9ff
movq %r15, %rdi
callq 0x7926
testb %al, %al
je 0x9ec3
leaq 0x583b(%rip), %rsi      # 0xf6ac
movq %r14, %rdi
callq 0x2310
movq %rbx, %rdi
callq 0x97e2
movq 0xb140(%rip), %rdi      # 0x14fc8
leaq 0x57e0(%rip), %rsi      # 0xf66f
callq 0x21a0
movq %rax, %rdi
callq 0x20f0
movslq 0x71ec(%rbx), %rax
andl $0x0, 0x71c4(%rbx,%rax,4)
jmp 0x9ecb
movq %rbx, %rdi
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x9672
movq %rbx, %rdi
callq 0x9672
leaq 0x57c2(%rip), %rsi      # 0xf694
leaq -0x50(%rbp), %rdi
leaq -0x29(%rbp), %rdx
callq 0x20a0
leaq -0x50(%rbp), %rsi
movq %r13, %rdi
callq 0x8572
leaq -0x50(%rbp), %rdi
callq 0x20d0
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x90(%rbp), %rdi
jmp 0x9f23
jmp 0x9f2a
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
jmp 0x9f23
jmp 0x9f2a
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x20d0
jmp 0x9f2d
movq %rax, %rbx
movq %rbx, %rdi
callq 0x22e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::Block()
void Parse::Block()
{where="B";check();
   //local variable for code gen
   int sLabel = startLabel ,vLabel = varLabel;
   
   if(LHS=="begin")
   {

      
      
      match();
      //call defptr then stat ptr
      DefPtr();
      //
      gen.emit3("DEFARG", vLabel, valLength[valLenPtr]);
      gen.emit2("DEFADDR", sLabel);
      //***
      
      StatPtr();
      
      if(LHS=="end")
      {
	 valLength[valLenPtr] = 0;
	 match();
	 
      }else
	 errorReport();
   }else
      errorReport();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
addq $0x5098, %rdi           # imm = 0x5098
leaq 0x5964(%rip), %rsi      # 0xf8d0
callq 0x2310
movq %rbx, %rdi
callq 0x97e2
movl 0x71bc(%rbx), %r12d
movl 0x71c0(%rbx), %r15d
leaq 0x5050(%rbx), %r14
leaq 0x5397(%rip), %rsi      # 0xf32c
movq %r14, %rdi
callq 0x7926
testb %al, %al
je 0xa056
movq %rbx, %rdi
callq 0x9522
movq %rbx, %rdi
callq 0xa0a8
leaq 0x56e0(%rip), %rsi      # 0xf69c
leaq -0x70(%rbp), %rdi
leaq -0x29(%rbp), %rdx
callq 0x20a0
leaq 0x50c0(%rbx), %r13
movslq 0x71ec(%rbx), %rax
movl 0x71c4(%rbx,%rax,4), %ecx
leaq -0x70(%rbp), %rsi
movq %r13, %rdi
movl %r12d, %edx
callq 0x8630
leaq -0x70(%rbp), %rdi
callq 0x20d0
leaq 0x56a6(%rip), %rsi      # 0xf6a3
leaq -0x50(%rbp), %rdi
leaq -0x29(%rbp), %rdx
callq 0x20a0
leaq -0x50(%rbp), %rsi
movq %r13, %rdi
movl %r15d, %edx
callq 0x85c6
leaq -0x50(%rbp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0xa1a4
leaq 0x5301(%rip), %rsi      # 0xf332
movq %r14, %rdi
callq 0x7926
testb %al, %al
je 0xa06c
movslq 0x71ec(%rbx), %rax
andl $0x0, 0x71c4(%rbx,%rax,4)
movq %rbx, %rdi
callq 0x9522
jmp 0xa074
movq %rbx, %rdi
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x9672
movq %rbx, %rdi
callq 0x9672
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x50(%rbp), %rdi
jmp 0xa095
jmp 0xa09c
movq %rax, %rbx
leaq -0x70(%rbp), %rdi
callq 0x20d0
jmp 0xa09f
movq %rax, %rbx
movq %rbx, %rdi
callq 0x22e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::DefPtr()
void Parse::DefPtr()
{where="DP";check();
// local code gen vars
   int varLength = 0;
   
   
   if(LHS=="const"||LHS=="integer"||LHS=="boolean"||LHS=="proc"||LHS=="Boolean")
   {  //calling def
      Def();
      
      
      if(LHS==";")
      {
	 match();
	 
	 DefPtr();
       
      }else if(LHS==".")
      {
      }else	 
	 errorReport();
   }  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x5098(%rdi), %r15
leaq 0x5050(%rdi), %r14
leaq 0x5268(%rip), %r13      # 0xf336
leaq 0x51f7(%rip), %r12      # 0xf2cc
movq %r15, %rdi
leaq 0x55cc(%rip), %rsi      # 0xf6ab
callq 0x2310
movq %rbx, %rdi
callq 0x97e2
movq %r14, %rdi
movq %r13, %rsi
callq 0x7926
testb %al, %al
jne 0xa147
movq %r14, %rdi
leaq 0x5237(%rip), %rsi      # 0xf33c
callq 0x7926
testb %al, %al
jne 0xa147
movq %r14, %rdi
leaq 0x5596(%rip), %rsi      # 0xf6ae
callq 0x7926
testb %al, %al
jne 0xa147
movq %r14, %rdi
leaq 0x4f01(%rip), %rsi      # 0xf02c
callq 0x7926
testb %al, %al
jne 0xa147
movq %r14, %rdi
leaq 0x5206(%rip), %rsi      # 0xf344
callq 0x7926
testb %al, %al
je 0xa17e
movq %rbx, %rdi
callq 0xa276
movq %r14, %rdi
movq %r12, %rsi
callq 0x7926
testb %al, %al
je 0xa16b
movq %rbx, %rdi
callq 0x9522
jmp 0xa0d5
leaq 0x588d(%rip), %rsi      # 0xf9ff
movq %r14, %rdi
callq 0x7926
testb %al, %al
je 0xa18d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x9672
nop
// File: /workspace/github_cpp_makefile_star2_O2/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::StatPtr()
void Parse::StatPtr()//statement part
{where="SP";check();

      Stat();
      if(LHS==";")
      {
	 match();
	 StatPtr();
      }else if(LHS=="end"||LHS=="[]"||LHS=="fi"||LHS=="od")
      {
      }else
	 errorReport();

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x5098(%rdi), %r15
leaq 0x5050(%rdi), %r14
leaq 0x55e8(%rip), %r12      # 0xf7b2
leaq 0x50fb(%rip), %r13      # 0xf2cc
movq %r15, %rdi
movq %r12, %rsi
callq 0x2310
movq %rbx, %rdi
callq 0x97e2
movq %rbx, %rdi
callq 0xae72
movq %r14, %rdi
movq %r13, %rsi
callq 0x7926
testb %al, %al
je 0xa205
movq %rbx, %rdi
callq 0x9522
jmp 0xa1d1
leaq 0x5126(%rip), %rsi      # 0xf332
movq %r14, %rdi
callq 0x7926
testb %al, %al
jne 0xa251
leaq 0x5152(%rip), %rsi      # 0xf371
movq %r14, %rdi
callq 0x7926
testb %al, %al
jne 0xa251
leaq 0x4e0d(%rip), %rsi      # 0xf03f
movq %r14, %rdi
callq 0x7926
testb %al, %al
jne 0xa251
leaq 0x5112(%rip), %rsi      # 0xf357
movq %r14, %rdi
callq 0x7926
testb %al, %al
je 0xa260
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x9672
// File: /workspace/github_cpp_makefile_star2_O2/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::Def()
void Parse::Def()//definition function
{where="D";check();

   
   if(LHS=="const")
   {
      //addone to the number of variables at the current block
      valLength[valLenPtr]++;

      //into const deff.
      ConstDef();
      //this adds the constant to the stack
      if(!checkDefConst())
	 scopeError("Ambiguous definition of constant");
      
   }else if(LHS=="integer"||LHS=="boolean"||LHS=="Boolean")
   {
      
      VarDef();
      if(!checkDefList())
	 scopeError("Ambiguious declaration in variable list");
   }else if(LHS=="proc")
   {
      //incriment to the next block
      valLenPtr++;

      ProcDef();

      //decrement to the previous block since end has been reached for current procedure
      valLenPtr--;
   }else
      errorReport();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
addq $0x5098, %rdi           # imm = 0x5098
leaq 0x5529(%rip), %rsi      # 0xf7bb
callq 0x2310
movq %rbx, %rdi
callq 0x97e2
leaq 0x5050(%rbx), %r14
leaq 0x5089(%rip), %rsi      # 0xf336
movq %r14, %rdi
callq 0x7926
testb %al, %al
je 0xa305
movslq 0x71ec(%rbx), %rax
incl 0x71c4(%rbx,%rax,4)
movq %rbx, %rdi
callq 0xa3e2
movq %rbx, %rdi
callq 0x997a
testb %al, %al
jne 0xa37b
leaq 0x53d0(%rip), %rsi      # 0xf6b6
leaq -0x58(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0x20a0
leaq -0x58(%rbp), %rsi
movq %rbx, %rdi
callq 0x9890
leaq -0x58(%rbp), %rdi
jmp 0xa376
leaq 0x5030(%rip), %rsi      # 0xf33c
movq %r14, %rdi
callq 0x7926
testb %al, %al
jne 0xa33e
leaq 0x538f(%rip), %rsi      # 0xf6ae
movq %r14, %rdi
callq 0x7926
testb %al, %al
jne 0xa33e
leaq 0x5012(%rip), %rsi      # 0xf344
movq %r14, %rdi
callq 0x7926
testb %al, %al
je 0xa384
movq %rbx, %rdi
callq 0xa468
movq %rbx, %rdi
callq 0x9a7e
testb %al, %al
jne 0xa37b
leaq 0x537e(%rip), %rsi      # 0xf6d7
leaq -0x38(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0x20a0
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
callq 0x9890
leaq -0x38(%rbp), %rdi
callq 0x20d0
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x4ca1(%rip), %rsi      # 0xf02c
movq %r14, %rdi
callq 0x7926
testb %al, %al
je 0xa3ad
incl 0x71ec(%rbx)
movq %rbx, %rdi
callq 0xa4fe
decl 0x71ec(%rbx)
jmp 0xa37b
movq %rbx, %rdi
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x9672
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
jmp 0xa3cf
jmp 0xa3d6
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x20d0
jmp 0xa3d9
movq %rax, %rbx
movq %rbx, %rdi
callq 0x22e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::ConstDef()
void Parse::ConstDef()
{where="CD";check();
   if(LHS=="const")
   {  //Initializing
      eType = UNIVERSAL;
      eKind = CONSTANT;
      //
      match();
      ConstName();
      if(LHS=="=")
      {
	 match();
	 Const();
      }
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
addq $0x5098, %rdi           # imm = 0x5098
leaq 0x5305(%rip), %rsi      # 0xf6ff
callq 0x2310
movq %rbx, %rdi
callq 0x97e2
leaq 0x5050(%rbx), %r14
leaq 0x4f21(%rip), %rsi      # 0xf336
movq %r14, %rdi
callq 0x7926
testb %al, %al
je 0xa463
movq $0x2, 0x4dd4(%rbx)
movq %rbx, %rdi
callq 0x9522
movq %rbx, %rdi
callq 0xa766
leaq 0x4f32(%rip), %rsi      # 0xf375
movq %r14, %rdi
callq 0x7926
testb %al, %al
je 0xa463
movq %rbx, %rdi
callq 0x9522
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xa7d6
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::VarDef()
void Parse::VarDef()//variable definition
{where="VD";check();
   listDepth = 0;
   if(LHS=="boolean"||LHS=="Boolean"||LHS=="integer")
   {  //varKind
      eKind=VAR;
      //
      TypeSym();
      VarDefB();     
   }else
   {
      errorReport();
   } 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
addq $0x5098, %rdi           # imm = 0x5098
leaq 0x5282(%rip), %rsi      # 0xf702
callq 0x2310
movq %rbx, %rdi
callq 0x97e2
andl $0x0, 0x4d88(%rbx)
leaq 0x5050(%rbx), %r14
leaq 0x520c(%rip), %rsi      # 0xf6ae
movq %r14, %rdi
callq 0x7926
testb %al, %al
jne 0xa4d4
leaq 0x4e8f(%rip), %rsi      # 0xf344
movq %r14, %rdi
callq 0x7926
testb %al, %al
jne 0xa4d4
leaq 0x4e74(%rip), %rsi      # 0xf33c
movq %r14, %rdi
callq 0x7926
testb %al, %al
je 0xa4f2
movl $0x1, 0x4dd8(%rbx)
movq %rbx, %rdi
callq 0xa934
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xa9c4
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x9672
// File: /workspace/github_cpp_makefile_star2_O2/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::ConstName()
void Parse::ConstName()//constant name
{where="CN";check();
   if(LHS=="id")
   {  //initialise index
      index=ln[tokeNum][1];
      //cout<<endl<<index<<"  "<<LHS<<"  "<<endl;
      match();
   }else
      errorReport();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x5098, %rdi           # imm = 0x5098
leaq 0x515b(%rip), %rsi      # 0xf8d8
callq 0x2310
movq %rbx, %rdi
callq 0x97e2
leaq 0x5050(%rbx), %rdi
leaq 0x4be2(%rip), %rsi      # 0xf37a
callq 0x7926
testb %al, %al
je 0xa7c7
movslq 0x2028(%rbx), %rax
imulq $0xc, %rax, %rax
movl 0x2034(%rbx,%rax), %eax
movl %eax, 0x4ddc(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x9522
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x9672
nop
// File: /workspace/github_cpp_makefile_star2_O2/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::Const()
void Parse::Const()//constant
{where="C";check();
   eKind = CONSTANT;
   if(LHS=="num")
   {  //
      eType = INT;
      
      Num();
  
   }else if(LHS=="true"||LHS=="false")
   {  //
      eType = BOOL;
      BoolSym();
   }else if(LHS=="id")
   {

      ConstName();
      tempEnt = bTable.find_all_level(index);
      tpVl = tempEnt.value;

      if(!bTable.inScope)
	 scopeError("Error, Variable not declared in scope");
   }else
      errorReport();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
addq $0x5098, %rdi           # imm = 0x5098
leaq 0x502e(%rip), %rsi      # 0xf820
callq 0x2310
movq %rbx, %rdi
callq 0x97e2
andl $0x0, 0x4dd8(%rbx)
leaq 0x5050(%rbx), %r14
leaq 0x4ab0(%rip), %rsi      # 0xf2c4
movq %r14, %rdi
callq 0x7926
testb %al, %al
je 0xa837
andl $0x0, 0x4dd4(%rbx)
movq %rbx, %rdi
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0xc662
leaq 0x4b22(%rip), %rsi      # 0xf360
movq %r14, %rdi
callq 0x7926
testb %al, %al
jne 0xa85d
leaq 0x4b09(%rip), %rsi      # 0xf35a
movq %r14, %rdi
callq 0x7926
testb %al, %al
je 0xa877
movl $0x1, 0x4dd4(%rbx)
movq %rbx, %rdi
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0xc6d8
leaq 0x4afc(%rip), %rsi      # 0xf37a
movq %r14, %rdi
callq 0x7926
testb %al, %al
je 0xa90f
movq %rbx, %rdi
callq 0xa766
leaq 0x4c38(%rbx), %rsi
movl 0x4ddc(%rbx), %edx
leaq -0x4c(%rbp), %r14
movq %r14, %rdi
callq 0xcb82
movups (%r14), %xmm0
movups 0xc(%r14), %xmm1
movups %xmm1, 0x4e38(%rbx)
movups %xmm0, 0x4e2c(%rbx)
movl 0x4e3c(%rbx), %eax
movl %eax, 0x7228(%rbx)
cmpb $0x0, 0x4c38(%rbx)
jne 0xa906
leaq 0x4e27(%rip), %rsi      # 0xf709
leaq -0x30(%rbp), %r14
leaq -0x4c(%rbp), %rdx
movq %r14, %rdi
callq 0x20a0
movq %rbx, %rdi
movq %r14, %rsi
callq 0x9890
leaq -0x30(%rbp), %rdi
callq 0x20d0
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
addq $0x40, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x9672
movq %rax, %rbx
leaq -0x30(%rbp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x22e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::TypeSym()
void Parse::TypeSym()//Type Symbol
{where="TS";check();
   if(LHS=="integer")
   {
      eType = INT;
      
      match();
   }else if(LHS=="boolean"||LHS=="Boolean")
   {
      eType = BOOL;
      match();
   }else
      errorReport();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
addq $0x5098, %rdi           # imm = 0x5098
leaq 0x4e01(%rip), %rsi      # 0xf74d
callq 0x2310
movq %rbx, %rdi
callq 0x97e2
leaq 0x5050(%rbx), %r14
leaq 0x49d5(%rip), %rsi      # 0xf33c
movq %r14, %rdi
callq 0x7926
testb %al, %al
je 0xa97c
andl $0x0, 0x4dd4(%rbx)
jmp 0xa9ac
leaq 0x4d2b(%rip), %rsi      # 0xf6ae
movq %r14, %rdi
callq 0x7926
testb %al, %al
jne 0xa9a2
leaq 0x49ae(%rip), %rsi      # 0xf344
movq %r14, %rdi
callq 0x7926
testb %al, %al
je 0xa9b8
movl $0x1, 0x4dd4(%rbx)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x9522
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x9672
// File: /workspace/github_cpp_makefile_star2_O2/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::VarList()
void Parse::VarList()//variable list
{where="VL";check();
   if(LHS=="id")
   {  //cout<<ln[tokeNum][1]<<where;
      varListIndex[listDepth] = ln[tokeNum][1];
      varListVal[listDepth] = 0;
      listDepth++;
      VarName();
      VarListB();
   }else
      errorReport();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x5098, %rdi           # imm = 0x5098
leaq 0x4ad9(%rip), %rsi      # 0xf750
callq 0x2310
movq %rbx, %rdi
callq 0x97e2
leaq 0x5050(%rbx), %rdi
leaq 0x46e8(%rip), %rsi      # 0xf37a
callq 0x7926
testb %al, %al
je 0xace6
movslq 0x2028(%rbx), %rax
imulq $0xc, %rax, %rax
movl 0x2034(%rbx,%rax), %eax
movslq 0x4d88(%rbx), %rcx
movl %eax, 0x4d38(%rbx,%rcx,4)
movslq 0x4d88(%rbx), %rax
andl $0x0, 0x4d60(%rbx,%rax,4)
incl 0x4d88(%rbx)
movq %rbx, %rdi
callq 0xacf4
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xad5c
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x9672
// File: /workspace/github_cpp_makefile_star2_O2/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::VarName()
void Parse::VarName()//variable name
{where="VN";check();
   if(LHS=="id")
   {  //initialise index
      //cout<<index;
      index = ln[tokeNum][1];
      match();
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x5098, %rdi           # imm = 0x5098
leaq 0x4bca(%rip), %rsi      # 0xf8d5
callq 0x2310
movq %rbx, %rdi
callq 0x97e2
leaq 0x5050(%rbx), %rdi
leaq 0x4654(%rip), %rsi      # 0xf37a
callq 0x7926
testb %al, %al
je 0xad55
movslq 0x2028(%rbx), %rax
imulq $0xc, %rax, %rax
movl 0x2034(%rbx,%rax), %eax
movl %eax, 0x4ddc(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x9522
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::VarListB()
void Parse::VarListB()//variable list for multiple itiretions
{where="VLB";check();
   if(LHS==",")
   {
      valLength[valLenPtr]++;
      match();
      //cout<<ln[tokeNum][1]<<where;
      varListIndex[listDepth] = ln[tokeNum][1];
      listDepth++;
      VarName();
      VarListB();
   }else
   {
      
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x5098(%rdi), %r14
leaq 0x5050(%rdi), %r15
leaq 0x2030(%rdi), %r12
leaq 0x45de(%rip), %r13      # 0xf367
movq %r14, %rdi
leaq 0x49c0(%rip), %rsi      # 0xf753
callq 0x2310
movq %rbx, %rdi
callq 0x97e2
movq %r15, %rdi
movq %r13, %rsi
callq 0x7926
testb %al, %al
je 0xadf3
movslq 0x71ec(%rbx), %rax
incl 0x71c4(%rbx,%rax,4)
movq %rbx, %rdi
callq 0x9522
movslq 0x2028(%rbx), %rax
imulq $0xc, %rax, %rax
movl 0x4(%r12,%rax), %eax
movslq 0x4d88(%rbx), %rcx
movl %eax, 0x4d38(%rbx,%rcx,4)
incl 0x4d88(%rbx)
movq %rbx, %rdi
callq 0xacf4
jmp 0xad89
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::ProcName()
void Parse::ProcName()//procedure name
{where="PN";check();
   if(LHS=="id")
   {  //initialise index
      index = ln[tokeNum][1];
      match();
   }else
      errorReport();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x5098, %rdi           # imm = 0x5098
leaq 0x4ac2(%rip), %rsi      # 0xf8db
callq 0x2310
movq %rbx, %rdi
callq 0x97e2
leaq 0x5050(%rbx), %rdi
leaq 0x4546(%rip), %rsi      # 0xf37a
callq 0x7926
testb %al, %al
je 0xae63
movslq 0x2028(%rbx), %rax
imulq $0xc, %rax, %rax
movl 0x2034(%rbx,%rax), %eax
movl %eax, 0x4ddc(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x9522
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x9672
nop
// File: /workspace/github_cpp_makefile_star2_O2/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::Stat()
void Parse::Stat()//statement
{where="S";check();
   if(LHS=="[]"||LHS=="fi"||LHS=="od")
   {     
   }else if(LHS=="read")
   {
      ReadStat();
   }else if(LHS=="skip")
   {
      EmptyStat();
   }else if(LHS=="write")
   {
      WriteStat();
   }else if(LHS=="id")
   {
      AsnStat();
   }else if(LHS=="call") 
   {
      ProcStat();
   }else if(LHS=="if")
   {
      IfStat();
   }else if(LHS=="do")
   {
      DoStat();
   }else if(LHS=="end")
   {
   }else
      errorReport();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
addq $0x5098, %rdi           # imm = 0x5098
leaq 0x494d(%rip), %rsi      # 0xf7d7
callq 0x2310
movq %rbx, %rdi
callq 0x97e2
leaq 0x5050(%rbx), %r14
leaq 0x44cc(%rip), %rsi      # 0xf371
movq %r14, %rdi
callq 0x7926
testb %al, %al
jne 0xaed7
leaq 0x4187(%rip), %rsi      # 0xf03f
movq %r14, %rdi
callq 0x7926
testb %al, %al
jne 0xaed7
leaq 0x448c(%rip), %rsi      # 0xf357
movq %r14, %rdi
callq 0x7926
testb %al, %al
je 0xaedc
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x418c(%rip), %rsi      # 0xf06f
movq %r14, %rdi
callq 0x7926
testb %al, %al
je 0xaefb
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xafd8
leaq 0x444a(%rip), %rsi      # 0xf34c
movq %r14, %rdi
callq 0x7926
testb %al, %al
je 0xaf1a
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xb082
leaq 0x416b(%rip), %rsi      # 0xf08c
movq %r14, %rdi
callq 0x7926
testb %al, %al
je 0xaf39
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xb0b4
leaq 0x443a(%rip), %rsi      # 0xf37a
movq %r14, %rdi
callq 0x7926
testb %al, %al
je 0xaf58
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xb15e
leaq 0x40be(%rip), %rsi      # 0xf01d
movq %r14, %rdi
callq 0x7926
testb %al, %al
je 0xaf77
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xb216
leaq 0x43d3(%rip), %rsi      # 0xf351
movq %r14, %rdi
callq 0x7926
testb %al, %al
je 0xaf96
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xb350
leaq 0x43b7(%rip), %rsi      # 0xf354
movq %r14, %rdi
callq 0x7926
testb %al, %al
je 0xafb5
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xb4b6
leaq 0x4376(%rip), %rsi      # 0xf332
movq %r14, %rdi
callq 0x7926
testb %al, %al
jne 0xaed7
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x9672