LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/navrajsaini[P]PL_Compiler_design_project/symboltable.cpp
// Function: Symtable::search(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int Symtable::search(string s)
{
   Token a;
   string comp;
   for (/*std::size_t*/int i = 0; i < 307; i++)//check all the loctions that are
      //occupied
   {
      a = htable[i];
      comp = a.getLexeme();
      if ( spellS (a.getSymbol()) != "NONAME")
      {
	 if ( comp == s )
	 {
	    return i;//if found return it's location
	 }
	 else
	    ;
      }
      else
	 ;
   }
   return -1;//return -1 if not found
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, -0x38(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x9cea
leaq -0x48(%rbp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
xorl %ebx, %ebx
leaq -0x78(%rbp), %r12
xorl %r14d, %r14d
xorl %r15d, %r15d
movq -0x38(%rbp), %rax
movq (%rax), %r13
leaq (%rbx,%r13), %rsi
addq $0x8, %rsi
movl -0x8(%rsi), %eax
movl %eax, -0xa8(%rbp)
leaq -0xa0(%rbp), %rdi
callq 0x2100
movl 0x28(%r13,%rbx), %eax
movl %eax, -0x80(%rbp)
leaq -0x68(%rbp), %r13
movq %r13, -0x78(%rbp)
movq -0xa0(%rbp), %rsi
movq -0x98(%rbp), %rdx
addq %rsi, %rdx
movq %r12, %rdi
callq 0x424c
leaq -0x58(%rbp), %rdi
movq %r12, %rsi
callq 0x2240
movq -0x78(%rbp), %rdi
cmpq %r13, %rdi
je 0x9680
callq 0x21b0
movl -0x80(%rbp), %esi
movq %r12, %rdi
callq 0x4388
movq %r12, %rdi
leaq 0x9c6c(%rip), %rsi      # 0x13301
callq 0x2080
movl %eax, %r13d
movq -0x78(%rbp), %rdi
leaq -0x68(%rbp), %rax
cmpq %rax, %rdi
je 0x96af
callq 0x21b0
testl %r13d, %r13d
je 0x96de
movq -0x50(%rbp), %rdx
movq -0x30(%rbp), %rax
cmpq 0x8(%rax), %rdx
jne 0x96de
movq -0x58(%rbp), %r13
testq %rdx, %rdx
je 0x970b
movq -0x30(%rbp), %rax
movq (%rax), %rsi
movq %r13, %rdi
callq 0x21e0
testl %eax, %eax
je 0x970b
cmpq $0x132, %r14            # imm = 0x132
leaq 0x1(%r14), %rax
setae %r15b
addq $0x30, %rbx
movq %rax, %r14
cmpq $0x133, %rax            # imm = 0x133
jne 0x9619
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
movq -0x58(%rbp), %r13
jmp 0x9718
testb $0x1, %r15b
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
cmovel %r14d, %ebx
leaq -0x48(%rbp), %rax
cmpq %rax, %r13
je 0x9729
movq %r13, %rdi
callq 0x21b0
leaq -0x90(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x973e
callq 0x21b0
movl %ebx, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9756
jmp 0x9756
movq %rax, %rbx
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0x976b
callq 0x21b0
leaq -0x90(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9780
callq 0x21b0
movq %rbx, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O3/navrajsaini[P]PL_Compiler_design_project/symboltable.cpp
// Function: Symtable::printTable()
void Symtable::printTable()
{
   Token a;
   for (std::size_t i = 0; i < 307; i++)
   {
      a = htable[i];
      if (spellS (a.getSymbol()) != "NONAME")
      {
	 cout << a;
      }
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
leaq -0x58(%rbp), %rdi
callq 0x9cea
movl $0x28, %r15d
leaq -0x78(%rbp), %r12
leaq 0x9b1d(%rip), %r13      # 0x13301
movq (%rbx), %r14
leaq (%r14,%r15), %rsi
addq $-0x20, %rsi
movl -0x8(%rsi), %eax
movl %eax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x2100
movl (%r14,%r15), %esi
movl %esi, -0x30(%rbp)
movq %r12, %rdi
callq 0x4388
movq %r12, %rdi
movq %r13, %rsi
callq 0x2080
movl %eax, %r14d
movq -0x78(%rbp), %rdi
leaq -0x68(%rbp), %rax
cmpq %rax, %rdi
je 0x982d
callq 0x21b0
testl %r14d, %r14d
je 0x9842
movq 0xf78f(%rip), %rdi      # 0x18fc8
leaq -0x58(%rbp), %rsi
callq 0x4729
addq $0x30, %r15
cmpq $0x39b8, %r15           # imm = 0x39B8
jne 0x97e4
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9861
callq 0x21b0
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9872
movq %rax, %rbx
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9887
callq 0x21b0
movq %rbx, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x88, %rsp
movq %rdx, %r13
movq %rsi, %rbx
movq %rdi, %r15
movw $0x101, (%rdi)          # imm = 0x101
movb $0x0, 0x2(%rdi)
addq $0x8, %rdi
movq %rdi, -0x68(%rbp)
callq 0x2200
leaq 0x210(%r15), %r14
movq %r14, %rdi
callq 0x22e0
leaq 0x410(%r15), %r12
movq %r12, %rdi
callq 0x22e0
movq %r12, -0x60(%rbp)
leaq 0x610(%r15), %rax
movq %rax, -0x38(%rbp)
leaq 0x620(%r15), %rax
movq %rax, -0x58(%rbp)
movq %rax, 0x610(%r15)
xorl %eax, %eax
movq %rax, 0x618(%r15)
movb %al, 0x620(%r15)
leaq 0x630(%r15), %rcx
movq %rcx, -0x30(%rbp)
leaq 0x640(%r15), %rcx
movq %rcx, -0x50(%rbp)
movq %rcx, 0x630(%r15)
movq %rax, 0x638(%r15)
movb %al, 0x640(%r15)
leaq 0x650(%r15), %rdi
leaq 0x660(%r15), %rax
movq %rax, -0x40(%rbp)
movq %rax, 0x650(%r15)
leaq 0x8d89(%rip), %rsi      # 0x1313e
leaq 0x8d8a(%rip), %rdx      # 0x13146
movq %rdi, -0x48(%rbp)
callq 0x42ea
leaq 0x670(%r15), %r12
movq %r12, %rdi
callq 0xac94
movq (%r13), %rsi
movq %r14, %rdi
movl $0x10, %edx
callq 0x2040
movq %r14, %rdi
callq 0x2270
movq -0x38(%rbp), %rdi
movq %rbx, %rsi
callq 0x2100
movq -0x30(%rbp), %rdi
movq %r13, %rsi
callq 0x2100
leaq -0x98(%rbp), %rbx
movq %rbx, -0x10(%rbx)
movq 0x610(%r15), %rsi
movq 0x618(%r15), %rdx
addq %rsi, %rdx
leaq -0xa8(%rbp), %rdi
callq 0x424c
leaq -0x78(%rbp), %r13
movq %r13, -0x10(%r13)
movq 0x630(%r15), %rsi
movq 0x638(%r15), %rdx
addq %rsi, %rdx
leaq -0x88(%rbp), %rdi
callq 0x424c
leaq -0xa8(%rbp), %rsi
leaq -0x88(%rbp), %rdx
movq %r12, %rdi
callq 0xb134
movq -0x88(%rbp), %rdi
cmpq %r13, %rdi
je 0xa479
callq 0x21b0
movq -0xa8(%rbp), %rdi
cmpq %rbx, %rdi
je 0xa48a
callq 0x21b0
addq $0x678, %r15            # imm = 0x678
movq %r15, %rdi
callq 0x488c
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq -0x88(%rbp), %rdi
cmpq %r13, %rdi
je 0xa4c4
callq 0x21b0
jmp 0xa4c4
movq %rax, %r15
movq -0xa8(%rbp), %rdi
cmpq %rbx, %rdi
je 0xa4ee
callq 0x21b0
jmp 0xa4ee
movq %rax, %r15
jmp 0xa4f6
movq %rax, %r15
jmp 0xa508
movq %rax, %r15
jmp 0xa535
movq %rax, %r15
jmp 0xa53d
movq %rax, %r15
movq %r12, %rdi
callq 0x416e
movq -0x48(%rbp), %rax
movq (%rax), %rdi
cmpq -0x40(%rbp), %rdi
je 0xa508
callq 0x21b0
movq -0x30(%rbp), %rax
movq (%rax), %rdi
cmpq -0x50(%rbp), %rdi
je 0xa51a
callq 0x21b0
movq -0x38(%rbp), %rax
movq (%rax), %rdi
cmpq -0x58(%rbp), %rdi
je 0xa52c
callq 0x21b0
movq -0x60(%rbp), %rdi
callq 0x2290
movq %r14, %rdi
callq 0x2290
movq -0x68(%rbp), %rdi
callq 0x2060
movq %r15, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O3/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 %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movq %rdi, %r14
leaq 0x8(%rdi), %rbx
movq 0x610(%rdi), %rsi
movq %rbx, %rdi
movl $0x8, %edx
callq 0x2130
leaq 0x670(%r14), %r15
movq 0x8(%r14), %r13
leaq -0x130(%rbp), %r12
movl $0xff, %edx
movq %r12, %rdi
movl $0x20, %esi
callq 0x2110
movq -0x18(%r13), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %ecx
movl $0x100, %edx            # imm = 0x100
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2350
movq %r15, %rdi
movq %r12, %rsi
movl $0x100, %edx            # imm = 0x100
callq 0xb37c
incl 0x1298(%r14)
incl 0x1ce0(%r14)
movq 0x8(%r14), %r13
movq -0x18(%r13), %rax
testb $0x2, 0x28(%r14,%rax)
je 0xa5cd
movq %rbx, %rdi
callq 0x2050
movl $0x1, %eax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
movq %rbx, %rdi
movl $0x1, %edx
callq 0x20d0
cmpb $0x1, (%r15)
jne 0xaad2
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %rdi
callq 0x2210
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2140
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2270
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x78, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x8(%rdi), %rbx
leaq -0x29(%rbp), %rdx
movl $0x133, %esi            # imm = 0x133
movq %rbx, %rdi
callq 0xae10
movl $0x0, 0x20(%r12)
movl $0x1, 0xc2c(%r12)
leaq 0xc30(%r12), %rdi
movq %rdi, -0x58(%rbp)
callq 0x22e0
leaq 0xe30(%r12), %rax
movq %rax, -0x40(%rbp)
leaq 0xe40(%r12), %rax
movq %rax, -0x50(%rbp)
movq %rax, 0xe30(%r12)
xorl %eax, %eax
movq %rax, 0xe38(%r12)
movb %al, 0xe40(%r12)
leaq 0xe50(%r12), %rcx
movq %rcx, -0x38(%rbp)
leaq 0xe60(%r12), %rcx
movq %rcx, -0x48(%rbp)
movq %rcx, 0xe50(%r12)
movq %rax, 0xe58(%r12)
movb %al, 0xe60(%r12)
leaq -0x88(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq -0x98(%rbp), %rdi
callq 0x424c
leaq -0x68(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x78(%rbp), %rdi
callq 0x424c
leaq -0x98(%rbp), %rsi
movq -0x40(%rbp), %rdi
callq 0x2100
leaq -0x78(%rbp), %rsi
movq -0x38(%rbp), %rdi
callq 0x2100
movq -0x78(%rbp), %rdi
cmpq %r15, %rdi
je 0xb03e
callq 0x21b0
movq -0x98(%rbp), %rdi
cmpq %r13, %rdi
je 0xb04f
callq 0x21b0
movq %rbx, %rdi
callq 0x488c
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0xc28(%r12)
leaq 0x28(%r12), %rax
movl $0x1, %ecx
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
movq $0x0, (%rax,%rcx,4)
movslq 0xc2c(%r12), %rdx
leaq (%rdx,%rdx,2), %rcx
movl $0x0, 0x8(%rax,%rcx,4)
leal 0x1(%rdx), %ecx
movl %ecx, 0xc2c(%r12)
cmpq $0xfe, %rdx
jl 0xb073
movl $0x1, 0xc2c(%r12)
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
jmp 0xb0e0
movq %rax, %r12
jmp 0xb123
movq %rax, %r12
movq -0x78(%rbp), %rdi
cmpq %r15, %rdi
je 0xb0e0
callq 0x21b0
movq -0x98(%rbp), %rdi
cmpq %r13, %rdi
je 0xb0f6
callq 0x21b0
jmp 0xb0f6
movq %rax, %r12
movq -0x38(%rbp), %rax
movq (%rax), %rdi
cmpq -0x48(%rbp), %rdi
je 0xb108
callq 0x21b0
movq -0x40(%rbp), %rax
movq (%rax), %rdi
cmpq -0x50(%rbp), %rdi
je 0xb11a
callq 0x21b0
movq -0x58(%rbp), %rdi
callq 0x2290
movq %rbx, %rdi
callq 0x41f2
movq %r12, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O3/navrajsaini[P]PL_Compiler_design_project/scanner.cpp
// Function: Scanner::getNum(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int Scanner::getNum(string token)
{
   int storeVal;
   storeVal = symbolTable.insertNum(token);
   inc(storeVal);
   return storeVal;
   
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq -0x40(%rbp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x424c
movq %r14, %rdi
movq %r15, %rsi
callq 0x9890
movl %eax, %r14d
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0xb31c
callq 0x21b0
movslq 0xc2c(%rbx), %rax
leaq (%rax,%rax,2), %rax
movl %r14d, 0x2c(%rbx,%rax,4)
movl 0xc28(%rbx), %eax
movslq 0xc2c(%rbx), %rcx
leaq (%rcx,%rcx,2), %rdx
movl %eax, 0x28(%rbx,%rdx,4)
movl $0x0, 0x30(%rbx,%rdx,4)
leal 0x1(%rcx), %eax
movl %eax, 0xc2c(%rbx)
movl %r14d, %eax
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0xb373
callq 0x21b0
movq %rbx, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movl $0x0, 0x4ddc(%rdi)
movabsq $0x400000002, %rax      # imm = 0x400000002
movq %rax, 0x4dd4(%rdi)
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %rax, 0x4de4(%rdi)
xorl %eax, %eax
xorl %ecx, %ecx
movl %eax, 0x4d38(%rdi,%rcx,4)
movl %eax, 0x4d60(%rdi,%rcx,4)
movl $0x1, 0x4de8(%rdi,%rcx,4)
incq %rcx
cmpq $0xb, %rcx
jne 0xbf2c
movl $0x0, 0x4d88(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 0xc51b
retq
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movb $0x1, 0x50b8(%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
movq 0xca8e(%rip), %rdi      # 0x18fc8
movq %rax, %rsi
callq 0x2210
movq %rax, %r14
leaq 0x70cc(%rip), %rsi      # 0x13618
movl $0xd, %edx
movq %rax, %rdi
callq 0x2210
movslq 0x2028(%rbx), %rax
leaq (%rax,%rax,2), %rax
movl 0x2034(%rbx,%rax,4), %esi
movq %r14, %rdi
callq 0x22f0
movq %rax, %r14
leaq 0x70a9(%rip), %rsi      # 0x13626
movl $0xb, %edx
movq %rax, %rdi
callq 0x2210
movslq 0x2028(%rbx), %rax
leaq (%rax,%rax,2), %rax
movl 0x2030(%rbx,%rax,4), %esi
movq %r14, %rdi
callq 0x22f0
movq %rax, %r14
leaq 0x7084(%rip), %rsi      # 0x13632
movl $0xe, %edx
movq %rax, %rdi
callq 0x2210
movq 0x5070(%rbx), %rsi
movq 0x5078(%rbx), %rdx
movq %r14, %rdi
callq 0x2210
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2140
movb $0x0, 0x2c30(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x4d88(%rdi)
jle 0xc7c4
leaq 0x4c38(%rbx), %r14
xorl %r15d, %r15d
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 0x10558
addq $0x10, %rsp
testb %al, %al
je 0xc81a
movslq 0x7224(%rbx), %rax
incl 0x71fc(%rbx,%rax,4)
incq %r15
movslq 0x4d88(%rbx), %rax
cmpq %rax, %r15
jl 0xc762
movl $0x0, 0x4ddc(%rbx)
movabsq $0x400000002, %rax      # imm = 0x400000002
movq %rax, 0x4dd4(%rbx)
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %rax, 0x4de4(%rbx)
xorl %eax, %eax
xorl %ecx, %ecx
movl %eax, 0x4d38(%rbx,%rcx,4)
movl %eax, 0x4d60(%rbx,%rcx,4)
movl $0x1, 0x4de8(%rbx,%rcx,4)
incq %rcx
cmpq $0xb, %rcx
jne 0xc7f4
movb $0x1, %al
jmp 0xc86c
movl $0x0, 0x4ddc(%rbx)
movabsq $0x400000002, %rax      # imm = 0x400000002
movq %rax, 0x4dd4(%rbx)
movabsq $0x100000000, %rax      # imm = 0x100000000
movq %rax, 0x4de4(%rbx)
xorl %eax, %eax
xorl %ecx, %ecx
movl %eax, 0x4d38(%rbx,%rcx,4)
movl %eax, 0x4d60(%rbx,%rcx,4)
movl $0x1, 0x4de8(%rbx,%rcx,4)
incq %rcx
cmpq $0xb, %rcx
jne 0xc84a
movl $0x0, 0x4d88(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
movq %rdi, %rbx
movq 0xc735(%rip), %r14      # 0x18fc8
testl %esi, %esi
je 0xc8eb
leaq 0x705e(%rip), %rsi      # 0x138fc
movl $0x7, %edx
movq %r14, %rdi
callq 0x2210
movl 0x4ddc(%rbx), %esi
movq %r14, %rdi
callq 0x22f0
movq %rax, %r14
leaq 0x704a(%rip), %rsi      # 0x1390d
movl $0x1, %edx
movq %rax, %rdi
callq 0x2210
movq 0x5070(%rbx), %rsi
movq 0x5078(%rbx), %rdx
movq %r14, %rdi
callq 0x2210
movq %rax, %r14
jmp 0xc92c
leaq 0x6d4f(%rip), %rsi      # 0x13641
movl $0x9, %edx
movq %r14, %rdi
callq 0x2210
movslq 0x4d88(%rbx), %rax
movl 0x4d34(%rbx,%rax,4), %esi
movq %r14, %rdi
callq 0x22f0
movq %rax, %r14
leaq 0x6fee(%rip), %rsi      # 0x1390d
movl $0x1, %edx
movq %rax, %rdi
callq 0x2210
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2140
movq 0x5050(%rbx), %rsi
movq 0x5058(%rbx), %rdx
movq %rax, %rdi
callq 0x2210
movq %rax, %r14
leaq 0x6f99(%rip), %rsi      # 0x1390c
movl $0x2, %edx
movq %rax, %rdi
callq 0x2210
movslq 0x2028(%rbx), %rax
leaq (%rax,%rax,2), %rax
movl 0x2034(%rbx,%rax,4), %esi
movq %r14, %rdi
callq 0x22f0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x2140
// File: /workspace/github_cpp_makefile_star2_O3/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 0x20(%rdi), %r14
leaq 0x702b(%rip), %rsi      # 0x13a0f
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xcc0f
addq $0x2044, %rbx           # imm = 0x2044
movl $0x1, %r15d
movl $0x3, %edx
movq 0xc5bb(%rip), %r13      # 0x18fc8
movq %r13, %rdi
leaq 0x6c34(%rip), %r12      # 0x1364b
movq %r12, %rsi
callq 0x2210
movq %r13, %rdi
movl %r15d, %esi
callq 0x22f0
movq %rax, %r13
movl $0x6, %edx
movq %rax, %rdi
leaq 0x6c13(%rip), %rsi      # 0x1364f
callq 0x2210
movl -0x8(%rbx), %esi
movq %r13, %rdi
callq 0x22f0
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %r13, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2140
movl $0x3, %edx
movq 0xc546(%rip), %r13      # 0x18fc8
movq %r13, %rdi
movq %r12, %rsi
callq 0x2210
movq %r13, %rdi
movl %r15d, %esi
callq 0x22f0
movq %rax, %r13
movl $0x6, %edx
movq %rax, %rdi
leaq 0x6bac(%rip), %rsi      # 0x13656
callq 0x2210
movl -0x4(%rbx), %esi
movq %r13, %rdi
callq 0x22f0
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %r13, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2140
movl $0x3, %edx
movq 0xc4d8(%rip), %r13      # 0x18fc8
movq %r13, %rdi
movq %r12, %rsi
callq 0x2210
movq %r13, %rdi
movq %r13, %r12
movl %r15d, %esi
callq 0x22f0
movq %rax, %r13
movl $0x6, %edx
movq %rax, %rdi
leaq 0x6b42(%rip), %rsi      # 0x1365d
callq 0x2210
movl (%rbx), %esi
movq %r13, %rdi
callq 0x22f0
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %r13, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2140
movl $0x6, %edx
movq %r12, %rdi
leaq 0x6b01(%rip), %rsi      # 0x13664
callq 0x2210
movq %r12, %rdi
movl %r15d, %esi
callq 0x22f0
movq %rax, %r13
movl $0x3, %edx
movq %rax, %rdi
leaq 0x6acd(%rip), %rsi      # 0x13652
callq 0x2210
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r13, %rdi
callq 0x2210
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %r13, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2140
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %r13, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2140
addq $0x20, %r14
movq %r14, %rdi
leaq 0x6e14(%rip), %rsi      # 0x13a0f
callq 0x2080
addq $0xc, %rbx
incl %r15d
testl %eax, %eax
jne 0xca01
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 $0x58, %rsp
movq %rdi, %rbx
addq $0x5098, %rdi           # imm = 0x5098
movq 0x50a0(%rbx), %rdx
leaq 0x69e3(%rip), %rcx      # 0x138e0
movl $0x1, %r8d
xorl %esi, %esi
callq 0x22b0
movq %rbx, %rdi
callq 0xc3e8
movl 0x71bc(%rbx), %r13d
movl 0x71c0(%rbx), %r15d
leaq 0x5050(%rbx), %r14
leaq 0x63fa(%rip), %rsi      # 0x13328
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xcf50
movq %rbx, %rdi
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xc18c
movl %r15d, -0x2c(%rbp)
leaq 0x5070(%rbx), %rdi
movq %rdi, -0x38(%rbp)
movq %r14, %rsi
callq 0x2100
movslq 0x2028(%rbx), %rsi
shlq $0x5, %rsi
addq %rbx, %rsi
movq %r14, %rdi
callq 0x2100
incl 0x2028(%rbx)
movq %rbx, %rdi
callq 0xd0ba
leaq 0x50c0(%rbx), %r15
leaq -0x48(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0x670b(%rip), %rsi      # 0x136ac
leaq 0x670a(%rip), %rdx      # 0x136b2
leaq -0x58(%rbp), %r12
movq %r12, %rdi
callq 0x42ea
movslq 0x71ec(%rbx), %rax
movl 0x71c4(%rbx,%rax,4), %ecx
movq %r15, %rdi
movq %r12, %rsi
movl %r13d, %edx
callq 0xab98
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0xcfe2
callq 0x21b0
leaq -0x68(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x66c2(%rip), %rsi      # 0x136b3
leaq 0x66c2(%rip), %rdx      # 0x136ba
leaq -0x78(%rbp), %r12
movq %r12, %rdi
callq 0x42ea
movq %r15, %rdi
movq %r12, %rsi
movl -0x2c(%rbp), %edx
callq 0xaae4
movq -0x78(%rbp), %rdi
cmpq %r13, %rdi
je 0xd020
callq 0x21b0
movq %rbx, %rdi
callq 0xd1e8
leaq 0x62ff(%rip), %rsi      # 0x1332e
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xd045
movq %rbx, %rdi
callq 0xc18c
jmp 0xd07f
movslq 0x71ec(%rbx), %rax
movl $0x0, 0x71c4(%rbx,%rax,4)
movq -0x38(%rbp), %rdi
movq %r14, %rsi
callq 0x2100
movslq 0x2028(%rbx), %rsi
shlq $0x5, %rsi
addq %rbx, %rsi
movq %r14, %rdi
callq 0x2100
incl 0x2028(%rbx)
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x78(%rbp), %rdi
cmpq %r13, %rdi
jne 0xd0ac
jmp 0xd0b1
movq %rax, %rbx
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0xd0b1
callq 0x21b0
movq %rbx, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5070(%rdi), %r12
leaq 0x61e1(%rip), %r13      # 0x132c8
movq 0x50a0(%rbx), %rdx
movl $0x2, %r8d
movq %r15, %rdi
xorl %esi, %esi
leaq 0x65bb(%rip), %rcx      # 0x136bb
callq 0x22b0
movq %rbx, %rdi
callq 0xc3e8
movq %r14, %rdi
leaq 0x621b(%rip), %rsi      # 0x13332
callq 0x2080
testl %eax, %eax
je 0xd16c
movq %r14, %rdi
leaq 0x620e(%rip), %rsi      # 0x13338
callq 0x2080
testl %eax, %eax
je 0xd16c
movq %r14, %rdi
leaq 0x6581(%rip), %rsi      # 0x136be
callq 0x2080
testl %eax, %eax
je 0xd16c
movq %r14, %rdi
leaq 0x5ed7(%rip), %rsi      # 0x13027
callq 0x2080
testl %eax, %eax
je 0xd16c
movq %r14, %rdi
leaq 0x61dd(%rip), %rsi      # 0x13340
callq 0x2080
testl %eax, %eax
jne 0xd1d8
movq %rbx, %rdi
callq 0xd32c
movq %r14, %rdi
movq %r13, %rsi
callq 0x2080
testl %eax, %eax
jne 0xd1af
movq %r12, %rdi
movq %r14, %rsi
callq 0x2100
movslq 0x2028(%rbx), %rsi
shlq $0x5, %rsi
addq %rbx, %rsi
movq %r14, %rdi
callq 0x2100
incl 0x2028(%rbx)
jmp 0xd0e7
leaq 0x6859(%rip), %rsi      # 0x13a0f
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xd1d8
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xc18c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movq 0x50a0(%rdi), %rdx
leaq 0x65b4(%rip), %rcx      # 0x137c2
movl $0x2, %r8d
movq %r15, %rdi
xorl %esi, %esi
callq 0x22b0
movq %rbx, %rdi
callq 0xc3e8
movq %rbx, %rdi
callq 0xe2ae
leaq 0x5050(%rbx), %r14
leaq 0x608c(%rip), %rsi      # 0x132c8
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
jne 0xd2ba
leaq 0x5070(%rbx), %r12
leaq 0x6072(%rip), %r13      # 0x132c8
movq %r12, %rdi
movq %r14, %rsi
callq 0x2100
movslq 0x2028(%rbx), %rsi
shlq $0x5, %rsi
addq %rbx, %rsi
movq %r14, %rdi
callq 0x2100
incl 0x2028(%rbx)
movq 0x50a0(%rbx), %rdx
movl $0x2, %r8d
movq %r15, %rdi
xorl %esi, %esi
leaq 0x652c(%rip), %rcx      # 0x137c2
callq 0x22b0
movq %rbx, %rdi
callq 0xc3e8
movq %rbx, %rdi
callq 0xe2ae
movq %r14, %rdi
movq %r13, %rsi
callq 0x2080
testl %eax, %eax
je 0xd256
leaq 0x606d(%rip), %rsi      # 0x1332e
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xd31c
leaq 0x60a6(%rip), %rsi      # 0x1337a
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xd31c
leaq 0x6076(%rip), %rsi      # 0x1335d
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xd31c
leaq 0x6066(%rip), %rsi      # 0x13360
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xd31c
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xc18c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
addq $0x5098, %rdi           # imm = 0x5098
movq 0x50a0(%rbx), %rdx
leaq 0x647a(%rip), %rcx      # 0x137cb
movl $0x1, %r8d
xorl %esi, %esi
callq 0x22b0
movq %rbx, %rdi
callq 0xc3e8
leaq 0x5050(%rbx), %r14
leaq 0x5fbe(%rip), %rsi      # 0x13332
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xd431
leaq 0x5fad(%rip), %rsi      # 0x13338
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xd3e6
leaq 0x6320(%rip), %rsi      # 0x136be
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xd3e6
leaq 0x5f8f(%rip), %rsi      # 0x13340
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xd3e6
leaq 0x5c63(%rip), %rsi      # 0x13027
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xd499
movq %rbx, %rdi
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xc18c
movq %rbx, %rdi
callq 0xd5bc
movq %rbx, %rdi
callq 0xc742
testb %al, %al
jne 0xd48e
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x62da(%rip), %rsi      # 0x136e7
leaq 0x62fa(%rip), %rdx      # 0x1370e
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x42ea
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc50a
movq -0x38(%rbp), %rdi
jmp 0xd484
movslq 0x71ec(%rbx), %rax
incl 0x71c4(%rbx,%rax,4)
movq %rbx, %rdi
callq 0xd4d2
movq %rbx, %rdi
callq 0xc63e
testb %al, %al
jne 0xd48e
leaq -0x48(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x6264(%rip), %rsi      # 0x136c6
leaq 0x627d(%rip), %rdx      # 0x136e6
leaq -0x58(%rbp), %r14
movq %r14, %rdi
callq 0x42ea
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc50a
movq -0x58(%rbp), %rdi
cmpq %r15, %rdi
je 0xd48e
callq 0x21b0
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
incl 0x71ec(%rbx)
movq %rbx, %rdi
callq 0xd664
decl 0x71ec(%rbx)
jmp 0xd48e
movq %rax, %rbx
movq -0x58(%rbp), %rdi
jmp 0xd4bf
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0xd4c9
callq 0x21b0
movq %rbx, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x5098, %rdi           # imm = 0x5098
movq 0x50a0(%rbx), %rdx
leaq 0x621b(%rip), %rcx      # 0x1370f
movl $0x2, %r8d
xorl %esi, %esi
callq 0x22b0
movq %rbx, %rdi
callq 0xc3e8
leaq 0x5050(%rbx), %r14
leaq 0x5e1b(%rip), %rsi      # 0x13332
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
jne 0xd577
movq $0x2, 0x4dd4(%rbx)
leaq 0x5070(%rbx), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x2100
movslq 0x2028(%rbx), %rsi
shlq $0x5, %rsi
addq %rbx, %rsi
movq %r14, %rdi
callq 0x2100
incl 0x2028(%rbx)
movq %rbx, %rdi
callq 0xd972
leaq 0x5e13(%rip), %rsi      # 0x1337e
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xd582
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %r15, %rdi
movq %r14, %rsi
callq 0x2100
movslq 0x2028(%rbx), %rsi
shlq $0x5, %rsi
addq %rbx, %rsi
movq %r14, %rdi
callq 0x2100
incl 0x2028(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xda14
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movq 0x50a0(%rbx), %rdx
leaq 0x6137(%rip), %rcx      # 0x13712
movl $0x2, %r8d
xorl %esi, %esi
callq 0x22b0
movq %rbx, %rdi
callq 0xc3e8
movl $0x0, 0x4d88(%rbx)
leaq 0x5050(%rbx), %r14
leaq 0x60b6(%rip), %rsi      # 0x136be
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xd646
leaq 0x5d25(%rip), %rsi      # 0x13340
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xd646
leaq 0x5d0a(%rip), %rsi      # 0x13338
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xd646
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xc18c
movl $0x1, 0x4dd8(%rbx)
movq %rbx, %rdi
callq 0xdba2
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xdc68
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
movq %rdi, %rbx
addq $0x5098, %rdi           # imm = 0x5098
movq 0x50a0(%rbx), %rdx
leaq 0x5f57(%rip), %rcx      # 0x138e8
movl $0x2, %r8d
xorl %esi, %esi
callq 0x22b0
movq %rbx, %rdi
callq 0xc3e8
leaq 0x5050(%rbx), %r14
leaq 0x584b(%rip), %rsi      # 0x131ff
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xd9cc
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xc18c
movslq 0x2028(%rbx), %rax
leaq (%rax,%rax,2), %rax
movl 0x2034(%rbx,%rax,4), %eax
movl %eax, 0x4ddc(%rbx)
leaq 0x5070(%rbx), %rdi
movq %r14, %rsi
callq 0x2100
movslq 0x2028(%rbx), %rsi
shlq $0x5, %rsi
addq %rbx, %rsi
movq %r14, %rdi
callq 0x2100
incl 0x2028(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rdi, %rbx
addq $0x5098, %rdi           # imm = 0x5098
movq 0x50a0(%rbx), %rdx
leaq 0x5df7(%rip), %rcx      # 0x13830
movl $0x1, %r8d
xorl %esi, %esi
callq 0x22b0
movq %rbx, %rdi
callq 0xc3e8
movl $0x0, 0x4dd8(%rbx)
leaq 0x5050(%rbx), %r14
leaq 0x585a(%rip), %rsi      # 0x132c0
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xdad9
leaq 0x58f0(%rip), %rsi      # 0x13369
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xdabd
leaq 0x58d7(%rip), %rsi      # 0x13363
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xdabd
leaq 0x5760(%rip), %rsi      # 0x131ff
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xdaf5
movq %rbx, %rdi
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xc18c
movl $0x1, 0x4dd4(%rbx)
movq %rbx, %rdi
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x103a4
movl $0x0, 0x4dd4(%rbx)
movq %rbx, %rdi
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x102fc
movq %rbx, %rdi
callq 0xd972
leaq 0x4c38(%rbx), %rsi
movl 0x4ddc(%rbx), %edx
leaq -0x54(%rbp), %r14
movq %r14, %rdi
callq 0x10a12
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 0xdb7d
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x5bc8(%rip), %rsi      # 0x13719
leaq 0x5be6(%rip), %rdx      # 0x1373e
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x42ea
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc50a
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0xdb7d
callq 0x21b0
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0xdb99
callq 0x21b0
movq %rbx, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O3/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
movq 0x50a0(%rbx), %rdx
leaq 0x5b9c(%rip), %rcx      # 0x1375d
movl $0x2, %r8d
xorl %esi, %esi
callq 0x22b0
movq %rbx, %rdi
callq 0xc3e8
leaq 0x5050(%rbx), %r14
leaq 0x5754(%rip), %rsi      # 0x13338
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xdc2e
leaq 0x5ac7(%rip), %rsi      # 0x136be
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xdc22
leaq 0x5736(%rip), %rsi      # 0x13340
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xdc22
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xc18c
movl $0x1, 0x4dd4(%rbx)
jmp 0xdc38
movl $0x0, 0x4dd4(%rbx)
leaq 0x5070(%rbx), %rdi
movq %r14, %rsi
callq 0x2100
movslq 0x2028(%rbx), %rsi
shlq $0x5, %rsi
addq %rbx, %rsi
movq %r14, %rdi
callq 0x2100
incl 0x2028(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
movq 0x50a0(%rbx), %rdx
leaq 0x578c(%rip), %rcx      # 0x13760
movl $0x2, %r8d
xorl %esi, %esi
callq 0x22b0
movq %rbx, %rdi
callq 0xc3e8
leaq 0x5050(%rbx), %rdi
leaq 0x5208(%rip), %rsi      # 0x131ff
callq 0x2080
testl %eax, %eax
je 0xe00e
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xc18c
movslq 0x2028(%rbx), %rax
leaq (%rax,%rax,2), %rax
movl 0x2034(%rbx,%rax,4), %eax
movslq 0x4d88(%rbx), %rcx
movl %eax, 0x4d38(%rbx,%rcx,4)
movslq 0x4d88(%rbx), %rax
movl $0x0, 0x4d60(%rbx,%rax,4)
incl 0x4d88(%rbx)
movq %rbx, %rdi
callq 0xe05c
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xe0f2
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
movq %rdi, %rbx
addq $0x5098, %rdi           # imm = 0x5098
movq 0x50a0(%rbx), %rdx
leaq 0x586a(%rip), %rcx      # 0x138e5
movl $0x2, %r8d
xorl %esi, %esi
callq 0x22b0
movq %rbx, %rdi
callq 0xc3e8
leaq 0x5050(%rbx), %r14
leaq 0x5161(%rip), %rsi      # 0x131ff
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
jne 0xe0ed
movslq 0x2028(%rbx), %rax
leaq (%rax,%rax,2), %rax
movl 0x2034(%rbx,%rax,4), %eax
movl %eax, 0x4ddc(%rbx)
leaq 0x5070(%rbx), %rdi
movq %r14, %rsi
callq 0x2100
movslq 0x2028(%rbx), %rsi
shlq $0x5, %rsi
addq %rbx, %rsi
movq %r14, %rdi
callq 0x2100
incl 0x2028(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
movq 0x50a0(%rdi), %rdx
leaq 0x564b(%rip), %rcx      # 0x13763
movl $0x3, %r8d
movq %r14, %rdi
xorl %esi, %esi
callq 0x22b0
movq %rbx, %rdi
callq 0xc3e8
leaq 0x5050(%rbx), %r15
leaq 0x5232(%rip), %rsi      # 0x13370
movq %r15, %rdi
callq 0x2080
testl %eax, %eax
jne 0xe1fd
leaq 0x5070(%rbx), %r12
leaq 0x2030(%rbx), %r13
movslq 0x71ec(%rbx), %rax
incl 0x71c4(%rbx,%rax,4)
movq %r12, %rdi
movq %r15, %rsi
callq 0x2100
movslq 0x2028(%rbx), %rsi
shlq $0x5, %rsi
addq %rbx, %rsi
movq %r15, %rdi
callq 0x2100
movslq 0x2028(%rbx), %rax
leal 0x1(%rax), %ecx
movl %ecx, 0x2028(%rbx)
leaq (%rax,%rax,2), %rax
movl 0x10(%r13,%rax,4), %eax
movslq 0x4d88(%rbx), %rcx
movl %eax, 0x4d38(%rbx,%rcx,4)
incl 0x4d88(%rbx)
movq %rbx, %rdi
callq 0xe05c
movq 0x50a0(%rbx), %rdx
movl $0x3, %r8d
movq %r14, %rdi
xorl %esi, %esi
leaq 0x558a(%rip), %rcx      # 0x13763
callq 0x22b0
movq %rbx, %rdi
callq 0xc3e8
movq %r15, %rdi
leaq 0x5180(%rip), %rsi      # 0x13370
callq 0x2080
testl %eax, %eax
je 0xe15c
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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 %r14
pushq %rbx
movq %rdi, %rbx
addq $0x5098, %rdi           # imm = 0x5098
movq 0x50a0(%rbx), %rdx
leaq 0x56c0(%rip), %rcx      # 0x138eb
movl $0x2, %r8d
xorl %esi, %esi
callq 0x22b0
movq %rbx, %rdi
callq 0xc3e8
leaq 0x5050(%rbx), %r14
leaq 0x4fb1(%rip), %rsi      # 0x131ff
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xe266
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xc18c
movslq 0x2028(%rbx), %rax
leaq (%rax,%rax,2), %rax
movl 0x2034(%rbx,%rax,4), %eax
movl %eax, 0x4ddc(%rbx)
leaq 0x5070(%rbx), %rdi
movq %r14, %rsi
callq 0x2100
movslq 0x2028(%rbx), %rsi
shlq $0x5, %rsi
addq %rbx, %rsi
movq %r14, %rdi
callq 0x2100
incl 0x2028(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
movq 0x50a0(%rbx), %rdx
leaq 0x551a(%rip), %rcx      # 0x137e7
movl $0x1, %r8d
xorl %esi, %esi
callq 0x22b0
movq %rbx, %rdi
callq 0xc3e8
leaq 0x5050(%rbx), %r14
leaq 0x508a(%rip), %rsi      # 0x1337a
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xe3e2
leaq 0x5056(%rip), %rsi      # 0x1335d
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xe3e2
leaq 0x5042(%rip), %rsi      # 0x13360
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xe3e2
leaq 0x5018(%rip), %rsi      # 0x1334d
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xe3e7
leaq 0x4ffc(%rip), %rsi      # 0x13348
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xe3f3
leaq 0x4cfc(%rip), %rsi      # 0x1305f
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xe3ff
leaq 0x4e85(%rip), %rsi      # 0x131ff
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xe40b
leaq 0x4fc1(%rip), %rsi      # 0x13352
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xe417
leaq 0x4fb3(%rip), %rsi      # 0x13357
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xe423
leaq 0x4fa3(%rip), %rsi      # 0x1335a
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xe42f
leaq 0x4f64(%rip), %rsi      # 0x1332e
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xe3e2
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xc18c
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xe43c
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xe53a
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xe5a6
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xe6a4
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xe7b0
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xe948
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xeb72
nop
// File: /workspace/github_cpp_makefile_star2_O3/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::ReadStat()
void Parse::ReadStat()//read statement
{where="RS";check();
   if(LHS=="read")
   {
      
      match();
      VarAcList();
      
      gen.emit2("READ", tempSizeRead);
      tempSizeRead = 0;
      
   }else
   {

   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
addq $0x5098, %rdi           # imm = 0x5098
movq 0x50a0(%rbx), %rdx
leaq 0x5364(%rip), %rcx      # 0x137c5
movl $0x2, %r8d
xorl %esi, %esi
callq 0x22b0
movq %rbx, %rdi
callq 0xc3e8
leaq 0x5050(%rbx), %r14
leaq 0x4ec9(%rip), %rsi      # 0x1334d
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
jne 0xe516
leaq 0x5070(%rbx), %rdi
movq %r14, %rsi
callq 0x2100
movslq 0x2028(%rbx), %rsi
shlq $0x5, %rsi
addq %rbx, %rsi
movq %r14, %rdi
callq 0x2100
incl 0x2028(%rbx)
movq %rbx, %rdi
callq 0xed88
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x52f2(%rip), %rsi      # 0x137c8
leaq 0x52ef(%rip), %rdx      # 0x137cc
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x42ea
leaq 0x50c0(%rbx), %rdi
movl 0x71f0(%rbx), %edx
movq %r14, %rsi
callq 0xaae4
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0xe50c
callq 0x21b0
movl $0x0, 0x71f0(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0xe532
callq 0x21b0
movq %rbx, %rdi
callq 0x2310