LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: navrajsaini[P]PL_Compiler_design_project/scanner.cpp
// Function: Scanner::isSpecial(char)
bool Scanner::isSpecial (char a)
{
   switch(a)
   {
      case '.':
	 return true;
      case',':
	 return true;
      case';':
	 return true;
      case'[':
	 return true;
      case']':
	 return true;
      case'&':
	 return true;
      case'|':
	 return true;
      case'~':
	 return true;
      case'<':
	 return true;
      case'=':
	 return true;
      case'>':
	 return true;
      case'+':
	 return true;
      case'-':
	 return true;
      case'*':
	 return true;
      case'/':
	 return true; 
      case 92:// backslash is reserved so its being compared to casted ascii value
	 return true;
      case'(':
	 return true;
      case')':
	 return true;
      case':':
	 return true;
      default:
	 return false;
	 break;
	 
   }
   
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movsbl -0x11(%rbp), %eax
addl $-0x26, %eax
movl %eax, %ecx
movq %rcx, -0x20(%rbp)
subl $0x58, %eax
ja 0x13a9a
movq -0x20(%rbp), %rax
leaq 0xba85(%rip), %rcx      # 0x1f4a4
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
movb $0x1, -0x1(%rbp)
jmp 0x13a9e
movb $0x1, -0x1(%rbp)
jmp 0x13a9e
movb $0x1, -0x1(%rbp)
jmp 0x13a9e
movb $0x1, -0x1(%rbp)
jmp 0x13a9e
movb $0x1, -0x1(%rbp)
jmp 0x13a9e
movb $0x1, -0x1(%rbp)
jmp 0x13a9e
movb $0x1, -0x1(%rbp)
jmp 0x13a9e
movb $0x1, -0x1(%rbp)
jmp 0x13a9e
movb $0x1, -0x1(%rbp)
jmp 0x13a9e
movb $0x1, -0x1(%rbp)
jmp 0x13a9e
movb $0x1, -0x1(%rbp)
jmp 0x13a9e
movb $0x1, -0x1(%rbp)
jmp 0x13a9e
movb $0x1, -0x1(%rbp)
jmp 0x13a9e
movb $0x1, -0x1(%rbp)
jmp 0x13a9e
movb $0x1, -0x1(%rbp)
jmp 0x13a9e
movb $0x1, -0x1(%rbp)
jmp 0x13a9e
movb $0x1, -0x1(%rbp)
jmp 0x13a9e
movb $0x1, -0x1(%rbp)
jmp 0x13a9e
movb $0x1, -0x1(%rbp)
jmp 0x13a9e
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movl -0xc(%rbp), %edx
movq %rax, %rcx
addq $0x28, %rcx
movslq 0xc2c(%rax), %rsi
imulq $0xc, %rsi, %rsi
addq %rsi, %rcx
movl %edx, 0x4(%rcx)
movl 0xc28(%rax), %edx
movq %rax, %rcx
addq $0x28, %rcx
movslq 0xc2c(%rax), %rsi
imulq $0xc, %rsi, %rsi
addq %rsi, %rcx
movl %edx, (%rcx)
movq %rax, %rcx
addq $0x28, %rcx
movslq 0xc2c(%rax), %rdx
imulq $0xc, %rdx, %rdx
addq %rdx, %rcx
movl $0x0, 0x8(%rcx)
movl 0xc2c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xc2c(%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
addq $0x8, %rax
movq %rax, -0x58(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x20d0
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x8130
movl %eax, -0x48(%rbp)
jmp 0x13b6f
movl -0x48(%rbp), %eax
movl %eax, -0x14(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x2130
movq -0x60(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x13ab0
movl -0x14(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x2130
movq -0x40(%rbp), %rdi
callq 0x2340
nopw %cs:(%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
addq $0x8, %rax
movq %rax, -0x58(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x20d0
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x109f0
movl %eax, -0x48(%rbp)
jmp 0x13bff
movl -0x48(%rbp), %eax
movl %eax, -0x14(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x2130
movq -0x60(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x13ab0
movl -0x14(%rbp), %eax
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x2130
movq -0x40(%rbp), %rdi
callq 0x2340
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x15500
movl $0x0, -0xc(%rbp)
cmpl $0xa, -0xc(%rbp)
jg 0x14e52
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl $0x0, 0x4d38(%rax,%rcx,4)
movslq -0xc(%rbp), %rcx
movl $0x0, 0x4d60(%rax,%rcx,4)
movslq -0xc(%rbp), %rcx
movl $0x1, 0x4de8(%rax,%rcx,4)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x14e10
movq -0x18(%rbp), %rax
movl $0x0, 0x4d88(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
cmpl $0xa, -0xc(%rbp)
jge 0x14fcf
movq -0x18(%rbp), %rax
movslq -0xc(%rbp), %rcx
movl $0x0, 0x71c4(%rax,%rcx,4)
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x14fab
movq -0x18(%rbp), %rdi
movq %rdi, %rsi
addq $0x5050, %rsi           # imm = 0x5050
addq $0x5070, %rdi           # imm = 0x5070
callq 0x2030
movq -0x18(%rbp), %rdi
callq 0x15b10
movl $0x0, -0x10(%rbp)
cmpl $0xa, -0x10(%rbp)
jge 0x1501d
movq -0x18(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl $0x0, 0x71c4(%rax,%rcx,4)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x14ff9
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movb $0x0, 0x50c0(%rax)
movb 0x50b8(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x15306
movq -0x10(%rbp), %rax
movb $0x1, 0x50b8(%rax)
movq 0x11e77(%rip), %rdi     # 0x26fc8
movq 0x11e60(%rip), %rsi     # 0x26fb8
callq 0x21d0
movq %rax, %rdi
leaq 0xa542(%rip), %rsi      # 0x1f6a9
callq 0x21b0
movq %rax, %rdi
movq -0x10(%rbp), %rax
movl 0x2028(%rax), %esi
callq 0x2320
movq 0x11e43(%rip), %rdi     # 0x26fc8
leaq 0xa534(%rip), %rsi      # 0x1f6c0
callq 0x21b0
movq -0x10(%rbp), %rcx
movq %rcx, %rax
addq $0x2030, %rax           # imm = 0x2030
movslq 0x2028(%rcx), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %esi
movq 0x11e13(%rip), %rdi     # 0x26fc8
callq 0x2320
movq %rax, %rdi
leaq 0xa4fa(%rip), %rsi      # 0x1f6be
callq 0x21b0
movq %rax, %rdi
movq 0x11de5(%rip), %rsi     # 0x26fb8
callq 0x21d0
movq 0x11de9(%rip), %rdi     # 0x26fc8
leaq 0xa501(%rip), %rsi      # 0x1f6e7
callq 0x21b0
movq -0x10(%rbp), %rsi
addq $0x5098, %rsi           # imm = 0x5098
movq 0x11dcb(%rip), %rdi     # 0x26fc8
callq 0x2190
movq %rax, %rdi
leaq 0xa4b2(%rip), %rsi      # 0x1f6be
callq 0x21b0
movq %rax, %rdi
movq 0x11d9d(%rip), %rsi     # 0x26fb8
callq 0x21d0
movq 0x11da1(%rip), %rdi     # 0x26fc8
leaq 0xa4f2(%rip), %rsi      # 0x1f720
callq 0x21b0
movq -0x10(%rbp), %rsi
movq %rax, %rdi
addq $0x5050, %rsi           # imm = 0x5050
callq 0x2190
movq 0x11d7b(%rip), %rdi     # 0x26fc8
leaq 0xa4e5(%rip), %rsi      # 0x1f739
callq 0x21b0
movq -0x10(%rbp), %rcx
movq %rax, %rdi
movq %rcx, %rax
addq $0x2030, %rax           # imm = 0x2030
movslq 0x2028(%rcx), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl 0x4(%rax), %esi
callq 0x2320
movq %rax, %rdi
leaq 0xa435(%rip), %rsi      # 0x1f6be
callq 0x21b0
movq %rax, %rdi
movq 0x11d20(%rip), %rsi     # 0x26fb8
callq 0x21d0
movq 0x11d24(%rip), %rdi     # 0x26fc8
leaq 0xa4a5(%rip), %rsi      # 0x1f750
callq 0x21b0
movq -0x10(%rbp), %rcx
movq %rax, %rdi
movq %rcx, %rax
addq $0x2030, %rax           # imm = 0x2030
movslq 0x2028(%rcx), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl 0x8(%rax), %esi
callq 0x2320
movq %rax, %rdi
leaq 0xa3de(%rip), %rsi      # 0x1f6be
callq 0x21b0
movq %rax, %rdi
movq 0x11cc9(%rip), %rsi     # 0x26fb8
callq 0x21d0
movq -0x10(%rbp), %rax
movb $0x1, 0x2c31(%rax)
movb $0x0, 0x2c30(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rsi, -0x20(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movb $0x0, 0x50c0(%rax)
movb 0x2c31(%rax), %al
andb $0x1, %al
movzbl %al, %eax
cmpl $0x0, %eax
jne 0x154f7
movq -0x18(%rbp), %rax
movq -0x20(%rbp), %rsi
movb $0x1, 0x50b8(%rax)
movq 0x11b7b(%rip), %rdi     # 0x26fc8
callq 0x2190
movq %rax, %rdi
leaq 0xa30f(%rip), %rsi      # 0x1f76b
callq 0x21b0
movq -0x18(%rbp), %rcx
movq %rax, %rdi
movq %rcx, %rax
addq $0x2030, %rax           # imm = 0x2030
movslq 0x2028(%rcx), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl 0x4(%rax), %esi
callq 0x2320
movq %rax, %rdi
leaq 0xa2e8(%rip), %rsi      # 0x1f779
callq 0x21b0
movq -0x18(%rbp), %rcx
movq %rax, %rdi
movq %rcx, %rax
addq $0x2030, %rax           # imm = 0x2030
movslq 0x2028(%rcx), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %esi
callq 0x2320
movq %rax, %rdi
leaq 0xa2c0(%rip), %rsi      # 0x1f785
callq 0x21b0
movq -0x18(%rbp), %rsi
movq %rax, %rdi
addq $0x5070, %rsi           # imm = 0x5070
callq 0x2190
movq %rax, %rdi
movq 0x11ad1(%rip), %rsi     # 0x26fb8
callq 0x21d0
movq -0x18(%rbp), %rax
movb $0x0, 0x2c30(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x4ddc(%rax)
movl $0x4, 0x4dd8(%rax)
movl $0x2, 0x4dd4(%rax)
movl $0x0, 0x4de4(%rax)
movl $0x1, 0x4de8(%rax)
movl $0x0, 0x4d88(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movq %rax, %rdi
addq $0x4c38, %rdi           # imm = 0x4C38
movl 0x4ddc(%rax), %esi
movl 0x4dd8(%rax), %edx
movl 0x4dd4(%rax), %ecx
movl 0x4de8(%rax), %r8d
movl 0x4de4(%rax), %r9d
movslq 0x7224(%rax), %r10
movl 0x71fc(%rax,%r10,4), %eax
xorl %r10d, %r10d
movl %eax, (%rsp)
movl $0x0, 0x8(%rsp)
callq 0x1a130
testb $0x1, %al
jne 0x155c3
movq -0x18(%rbp), %rdi
callq 0x15500
movb $0x0, -0x1(%rbp)
jmp 0x155e8
movq -0x18(%rbp), %rdi
movslq 0x7224(%rdi), %rax
movl 0x71fc(%rdi,%rax,4), %ecx
addl $0x1, %ecx
movl %ecx, 0x71fc(%rdi,%rax,4)
callq 0x15500
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movq %rax, %rdi
addq $0x4c38, %rdi           # imm = 0x4C38
movl 0x4ddc(%rax), %esi
movl 0x4dd8(%rax), %edx
movl 0x4dd4(%rax), %ecx
movl -0x14(%rbp), %eax
xorl %r9d, %r9d
movl %r9d, %r8d
movl $0x0, (%rsp)
movl %eax, 0x8(%rsp)
callq 0x1a130
testb $0x1, %al
jne 0x1565f
movq -0x20(%rbp), %rdi
callq 0x15500
movb $0x0, -0x1(%rbp)
jmp 0x1566c
movq -0x20(%rbp), %rdi
callq 0x15500
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
movl $0x0, -0x14(%rbp)
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl 0x4d88(%rcx), %eax
jge 0x1574a
movq -0x20(%rbp), %rax
movq %rax, %rdi
addq $0x4c38, %rdi           # imm = 0x4C38
movslq -0x14(%rbp), %rcx
movl 0x4d38(%rax,%rcx,4), %esi
movl 0x4dd8(%rax), %edx
movl 0x4dd4(%rax), %ecx
movslq -0x14(%rbp), %r8
movl 0x4de8(%rax,%r8,4), %r8d
movslq -0x14(%rbp), %r9
movl 0x4d60(%rax,%r9,4), %r9d
movslq 0x7224(%rax), %r10
movl 0x71fc(%rax,%r10,4), %eax
xorl %r10d, %r10d
movl %eax, (%rsp)
movl $0x0, 0x8(%rsp)
callq 0x1a130
testb $0x1, %al
jne 0x15720
movq -0x20(%rbp), %rdi
callq 0x14df0
movb $0x0, -0x1(%rbp)
jmp 0x15757
movq -0x20(%rbp), %rax
movslq 0x7224(%rax), %rcx
movl 0x71fc(%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, 0x71fc(%rax,%rcx,4)
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x1569b
movq -0x20(%rbp), %rdi
callq 0x14df0
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
andb $0x1, %al
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
testb $0x1, -0x9(%rbp)
je 0x15843
movq 0x1182b(%rip), %rdi     # 0x26fc8
leaq 0xa2ab(%rip), %rsi      # 0x1fa4f
callq 0x21b0
movq %rax, %rdi
movq -0x18(%rbp), %rax
movl 0x4ddc(%rax), %esi
callq 0x2320
movq %rax, %rdi
leaq 0xa29b(%rip), %rsi      # 0x1fa60
callq 0x21b0
movq -0x18(%rbp), %rsi
movq %rax, %rdi
addq $0x5070, %rsi           # imm = 0x5070
callq 0x2190
movq %rax, %rdi
movq 0x117d1(%rip), %rsi     # 0x26fb8
callq 0x21d0
movq -0x18(%rbp), %rsi
movq %rax, %rdi
addq $0x5050, %rsi           # imm = 0x5050
callq 0x2190
movq %rax, %rdi
leaq 0xa256(%rip), %rsi      # 0x1fa5f
callq 0x21b0
movq -0x18(%rbp), %rcx
movq %rax, %rdi
movq %rcx, %rax
addq $0x2030, %rax           # imm = 0x2030
movslq 0x2028(%rcx), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl 0x4(%rax), %esi
callq 0x2320
movq %rax, %rdi
movq 0x1177a(%rip), %rsi     # 0x26fb8
callq 0x21d0
testb $0x1, -0x9(%rbp)
jne 0x158f4
movq 0x11774(%rip), %rdi     # 0x26fc8
leaq 0x9f39(%rip), %rsi      # 0x1f794
callq 0x21b0
movq %rax, %rdi
movq -0x18(%rbp), %rax
movl 0x4d88(%rax), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl 0x4d38(%rax,%rcx,4), %esi
callq 0x2320
movq %rax, %rdi
leaq 0xa1d7(%rip), %rsi      # 0x1fa60
callq 0x21b0
movq %rax, %rdi
movq 0x11720(%rip), %rsi     # 0x26fb8
callq 0x21d0
movq -0x18(%rbp), %rsi
movq %rax, %rdi
addq $0x5050, %rsi           # imm = 0x5050
callq 0x2190
movq %rax, %rdi
leaq 0xa1a5(%rip), %rsi      # 0x1fa5f
callq 0x21b0
movq -0x18(%rbp), %rcx
movq %rax, %rdi
movq %rcx, %rax
addq $0x2030, %rax           # imm = 0x2030
movslq 0x2028(%rcx), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl 0x4(%rax), %esi
callq 0x2320
movq %rax, %rdi
movq 0x116c9(%rip), %rsi     # 0x26fb8
callq 0x21d0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x1, -0xc(%rbp)
movq -0x18(%rbp), %rdi
movslq -0xc(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rdi
leaq 0xa232(%rip), %rsi      # 0x1fb63
callq 0x11240
testb $0x1, %al
jne 0x1593f
jmp 0x15ac2
movq 0x11682(%rip), %rdi     # 0x26fc8
leaq 0x9e51(%rip), %rsi      # 0x1f79e
callq 0x21b0
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x2320
movq %rax, %rdi
leaq 0x9e3b(%rip), %rsi      # 0x1f7a2
callq 0x21b0
movq %rax, %rdi
movq -0x18(%rbp), %rax
addq $0x2030, %rax           # imm = 0x2030
movslq -0xc(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl (%rax), %esi
callq 0x2320
movq %rax, %rdi
movq 0x11623(%rip), %rsi     # 0x26fb8
callq 0x21d0
movq 0x11627(%rip), %rdi     # 0x26fc8
leaq 0x9df6(%rip), %rsi      # 0x1f79e
callq 0x21b0
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x2320
movq %rax, %rdi
leaq 0x9de7(%rip), %rsi      # 0x1f7a9
callq 0x21b0
movq %rax, %rdi
movq -0x18(%rbp), %rax
addq $0x2030, %rax           # imm = 0x2030
movslq -0xc(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl 0x4(%rax), %esi
callq 0x2320
movq %rax, %rdi
movq 0x115c7(%rip), %rsi     # 0x26fb8
callq 0x21d0
movq 0x115cb(%rip), %rdi     # 0x26fc8
leaq 0x9d9a(%rip), %rsi      # 0x1f79e
callq 0x21b0
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x2320
movq %rax, %rdi
leaq 0x9d92(%rip), %rsi      # 0x1f7b0
callq 0x21b0
movq %rax, %rdi
movq -0x18(%rbp), %rax
addq $0x2030, %rax           # imm = 0x2030
movslq -0xc(%rbp), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl 0x8(%rax), %esi
callq 0x2320
movq %rax, %rdi
movq 0x1156b(%rip), %rsi     # 0x26fb8
callq 0x21d0
movq 0x1156f(%rip), %rdi     # 0x26fc8
leaq 0x9d57(%rip), %rsi      # 0x1f7b7
callq 0x21b0
movq %rax, %rdi
movl -0xc(%rbp), %esi
callq 0x2320
movq %rax, %rdi
leaq 0x9d2b(%rip), %rsi      # 0x1f7a5
callq 0x21b0
movq -0x18(%rbp), %rsi
movq %rax, %rdi
movslq -0xc(%rbp), %rax
shlq $0x5, %rax
addq %rax, %rsi
callq 0x2190
movq %rax, %rdi
movq 0x11518(%rip), %rsi     # 0x26fb8
callq 0x21d0
movq %rax, %rdi
movq 0x11509(%rip), %rsi     # 0x26fb8
callq 0x21d0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1591b
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0xa0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x78(%rbp)
addq $0x5098, %rdi           # imm = 0x5098
leaq 0x9b7e(%rip), %rsi      # 0x1fa33
callq 0x2280
movq -0x78(%rbp), %rdi
callq 0x15310
movq -0x78(%rbp), %rdi
movl 0x71c0(%rdi), %eax
movl %eax, -0xc(%rbp)
movl 0x71bc(%rdi), %eax
movl %eax, -0x10(%rbp)
addq $0x5050, %rdi           # imm = 0x5050
leaq 0x9445(%rip), %rsi      # 0x1f32c
callq 0x10ea0
testb $0x1, %al
jne 0x15ef5
jmp 0x1607f
movq -0x78(%rbp), %rdi
callq 0x14f20
movq -0x78(%rbp), %rdi
callq 0x160a0
movq -0x78(%rbp), %rax
addq $0x50c0, %rax           # imm = 0x50C0
movq %rax, -0x88(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x2350
movq -0x80(%rbp), %rdx
leaq 0x98cf(%rip), %rsi      # 0x1f7ff
leaq -0x30(%rbp), %rdi
callq 0x2290
jmp 0x15f3b
movq -0x88(%rbp), %rdi
movq -0x78(%rbp), %rax
movl -0x10(%rbp), %edx
movslq 0x71ec(%rax), %rcx
movl 0x71c4(%rax,%rcx,4), %ecx
leaq -0x30(%rbp), %rsi
callq 0x13010
jmp 0x15f62
leaq -0x30(%rbp), %rdi
callq 0x2130
leaq -0x31(%rbp), %rdi
callq 0x21e0
movq -0x78(%rbp), %rax
addq $0x50c0, %rax           # imm = 0x50C0
movq %rax, -0x98(%rbp)
leaq -0x69(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x2350
movq -0x90(%rbp), %rdx
leaq 0x9863(%rip), %rsi      # 0x1f806
leaq -0x68(%rbp), %rdi
callq 0x2290
jmp 0x15fae
movq -0x98(%rbp), %rdi
movl -0xc(%rbp), %edx
leaq -0x68(%rbp), %rsi
callq 0x12f70
jmp 0x15fc3
leaq -0x68(%rbp), %rdi
callq 0x2130
leaq -0x69(%rbp), %rdi
callq 0x21e0
movq -0x78(%rbp), %rdi
callq 0x161d0
movq -0x78(%rbp), %rdi
addq $0x5050, %rdi           # imm = 0x5050
leaq 0x9342(%rip), %rsi      # 0x1f332
callq 0x10ea0
testb $0x1, %al
jne 0x15ffb
jmp 0x16074
movq -0x78(%rbp), %rdi
movslq 0x71ec(%rdi), %rax
movl $0x0, 0x71c4(%rdi,%rax,4)
callq 0x14f20
jmp 0x1607d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x1603b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2130
leaq -0x31(%rbp), %rdi
callq 0x21e0
jmp 0x16091
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x16069
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x2130
leaq -0x69(%rbp), %rdi
callq 0x21e0
jmp 0x16091
movq -0x78(%rbp), %rdi
callq 0x15110
jmp 0x16088
movq -0x78(%rbp), %rdi
callq 0x15110
addq $0xa0, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x2340
nopw (%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
addq $0x5098, %rdi           # imm = 0x5098
leaq 0x974c(%rip), %rsi      # 0x1f80e
callq 0x2280
movq -0x18(%rbp), %rdi
callq 0x15310
movq -0x18(%rbp), %rdi
movl $0x0, -0xc(%rbp)
addq $0x5050, %rdi           # imm = 0x5050
leaq 0x924d(%rip), %rsi      # 0x1f336
callq 0x10ea0
testb $0x1, %al
jne 0x16160
movq -0x18(%rbp), %rdi
addq $0x5050, %rdi           # imm = 0x5050
leaq 0x9238(%rip), %rsi      # 0x1f33c
callq 0x10ea0
testb $0x1, %al
jne 0x16160
movq -0x18(%rbp), %rdi
addq $0x5050, %rdi           # imm = 0x5050
leaq 0x96f2(%rip), %rsi      # 0x1f811
callq 0x10ea0
testb $0x1, %al
jne 0x16160
movq -0x18(%rbp), %rdi
addq $0x5050, %rdi           # imm = 0x5050
leaq 0x8ef2(%rip), %rsi      # 0x1f02c
callq 0x10ea0
testb $0x1, %al
jne 0x16160
movq -0x18(%rbp), %rdi
addq $0x5050, %rdi           # imm = 0x5050
leaq 0x91ef(%rip), %rsi      # 0x1f344
callq 0x10ea0
testb $0x1, %al
jne 0x16160
jmp 0x161c6
movq -0x18(%rbp), %rdi
callq 0x162c0
movq -0x18(%rbp), %rdi
addq $0x5050, %rdi           # imm = 0x5050
leaq 0x9151(%rip), %rsi      # 0x1f2cc
callq 0x10ea0
testb $0x1, %al
jne 0x16186
jmp 0x1619a
movq -0x18(%rbp), %rdi
callq 0x14f20
movq -0x18(%rbp), %rdi
callq 0x160a0
jmp 0x161c4
movq -0x18(%rbp), %rdi
addq $0x5050, %rdi           # imm = 0x5050
leaq 0x99b7(%rip), %rsi      # 0x1fb63
callq 0x10ea0
testb $0x1, %al
jne 0x161b7
jmp 0x161b9
jmp 0x161c2
movq -0x18(%rbp), %rdi
callq 0x15110
jmp 0x161c4
jmp 0x161c6
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x5098, %rdi           # imm = 0x5098
leaq 0x9723(%rip), %rsi      # 0x1f915
callq 0x2280
movq -0x10(%rbp), %rdi
callq 0x15310
movq -0x10(%rbp), %rdi
callq 0x17580
movq -0x10(%rbp), %rdi
addq $0x5050, %rdi           # imm = 0x5050
leaq 0x90b1(%rip), %rsi      # 0x1f2cc
callq 0x10ea0
testb $0x1, %al
jne 0x16226
jmp 0x1623a
movq -0x10(%rbp), %rdi
callq 0x14f20
movq -0x10(%rbp), %rdi
callq 0x161d0
jmp 0x162b5
movq -0x10(%rbp), %rdi
addq $0x5050, %rdi           # imm = 0x5050
leaq 0x90e6(%rip), %rsi      # 0x1f332
callq 0x10ea0
testb $0x1, %al
jne 0x162a8
movq -0x10(%rbp), %rdi
addq $0x5050, %rdi           # imm = 0x5050
leaq 0x9108(%rip), %rsi      # 0x1f36f
callq 0x10ea0
testb $0x1, %al
jne 0x162a8
movq -0x10(%rbp), %rdi
addq $0x5050, %rdi           # imm = 0x5050
leaq 0x8dbd(%rip), %rsi      # 0x1f03f
callq 0x10ea0
testb $0x1, %al
jne 0x162a8
movq -0x10(%rbp), %rdi
addq $0x5050, %rdi           # imm = 0x5050
leaq 0x90ba(%rip), %rsi      # 0x1f357
callq 0x10ea0
testb $0x1, %al
jne 0x162a8
jmp 0x162aa
jmp 0x162b3
movq -0x10(%rbp), %rdi
callq 0x15110
jmp 0x162b5
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x5098, %rdi           # imm = 0x5098
leaq 0x9330(%rip), %rsi      # 0x1f862
callq 0x2280
movq -0x10(%rbp), %rdi
callq 0x15310
movq -0x10(%rbp), %rdi
addq $0x5050, %rdi           # imm = 0x5050
leaq 0x8de4(%rip), %rsi      # 0x1f336
callq 0x10ea0
testb $0x1, %al
jne 0x1655d
jmp 0x165b4
movq -0x10(%rbp), %rdi
movl $0x2, 0x4dd4(%rdi)
movl $0x0, 0x4dd8(%rdi)
callq 0x14f20
movq -0x10(%rbp), %rdi
callq 0x16b10
movq -0x10(%rbp), %rdi
addq $0x5050, %rdi           # imm = 0x5050
leaq 0x8dde(%rip), %rsi      # 0x1f373
callq 0x10ea0
testb $0x1, %al
jne 0x165a0
jmp 0x165b2
movq -0x10(%rbp), %rdi
callq 0x14f20
movq -0x10(%rbp), %rdi
callq 0x16ba0
jmp 0x165b4
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x5098, %rdi           # imm = 0x5098
leaq 0x9283(%rip), %rsi      # 0x1f865
callq 0x2280
movq -0x10(%rbp), %rdi
callq 0x15310
movq -0x10(%rbp), %rdi
movl $0x0, 0x4d88(%rdi)
addq $0x5050, %rdi           # imm = 0x5050
leaq 0x9205(%rip), %rsi      # 0x1f811
callq 0x10ea0
testb $0x1, %al
jne 0x1664d
movq -0x10(%rbp), %rdi
addq $0x5050, %rdi           # imm = 0x5050
leaq 0x8d1d(%rip), %rsi      # 0x1f344
callq 0x10ea0
testb $0x1, %al
jne 0x1664d
movq -0x10(%rbp), %rdi
addq $0x5050, %rdi           # imm = 0x5050
leaq 0x8cfa(%rip), %rsi      # 0x1f33c
callq 0x10ea0
testb $0x1, %al
jne 0x1664d
jmp 0x1666b
movq -0x10(%rbp), %rdi
movl $0x1, 0x4dd8(%rdi)
callq 0x16d80
movq -0x10(%rbp), %rdi
callq 0x16e40
jmp 0x16674
movq -0x10(%rbp), %rdi
callq 0x15110
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x5098, %rdi           # imm = 0x5098
leaq 0x8f09(%rip), %rsi      # 0x1fa3b
callq 0x2280
movq -0x10(%rbp), %rdi
callq 0x15310
movq -0x10(%rbp), %rdi
addq $0x5050, %rdi           # imm = 0x5050
leaq 0x8826(%rip), %rsi      # 0x1f378
callq 0x10ea0
testb $0x1, %al
jne 0x16b5d
jmp 0x16b88
movq -0x10(%rbp), %rdi
movq %rdi, %rax
addq $0x2030, %rax           # imm = 0x2030
movslq 0x2028(%rdi), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
movl %eax, 0x4ddc(%rdi)
callq 0x14f20
jmp 0x16b91
movq -0x10(%rbp), %rdi
callq 0x15110
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x70, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x68(%rbp)
addq $0x5098, %rdi           # imm = 0x5098
leaq 0x8dc1(%rip), %rsi      # 0x1f983
callq 0x2280
movq -0x68(%rbp), %rdi
callq 0x15310
movq -0x68(%rbp), %rdi
movl $0x0, 0x4dd8(%rdi)
addq $0x5050, %rdi           # imm = 0x5050
leaq 0x86d8(%rip), %rsi      # 0x1f2c4
callq 0x10ea0
testb $0x1, %al
jne 0x16bf7
jmp 0x16c0f
movq -0x68(%rbp), %rdi
movl $0x0, 0x4dd4(%rdi)
callq 0x19d90
jmp 0x16d6b
movq -0x68(%rbp), %rdi
addq $0x5050, %rdi           # imm = 0x5050
leaq 0x873f(%rip), %rsi      # 0x1f360
callq 0x10ea0
testb $0x1, %al
jne 0x16c47
movq -0x68(%rbp), %rdi
addq $0x5050, %rdi           # imm = 0x5050
leaq 0x871e(%rip), %rsi      # 0x1f35a
callq 0x10ea0
testb $0x1, %al
jne 0x16c47
jmp 0x16c5f
movq -0x68(%rbp), %rdi
movl $0x1, 0x4dd4(%rdi)
callq 0x19e30
jmp 0x16d69
movq -0x68(%rbp), %rdi
addq $0x5050, %rdi           # imm = 0x5050
leaq 0x8707(%rip), %rsi      # 0x1f378
callq 0x10ea0
testb $0x1, %al
jne 0x16c7f
jmp 0x16d5e
movq -0x68(%rbp), %rdi
callq 0x16b10
movq -0x68(%rbp), %rax
movq %rax, %rsi
addq $0x4c38, %rsi           # imm = 0x4C38
movl 0x4ddc(%rax), %edx
leaq -0x24(%rbp), %rdi
callq 0x1a870
movq -0x68(%rbp), %rax
movq -0x24(%rbp), %rcx
movq %rcx, 0x4e2c(%rax)
movq -0x1c(%rbp), %rcx
movq %rcx, 0x4e34(%rax)
movq -0x14(%rbp), %rcx
movq %rcx, 0x4e3c(%rax)
movl -0xc(%rbp), %ecx
movl %ecx, 0x4e44(%rax)
movl 0x4e3c(%rax), %ecx
movl %ecx, 0x7228(%rax)
testb $0x1, 0x4c38(%rax)
jne 0x16d5c
leaq -0x49(%rbp), %rdi
movq %rdi, -0x70(%rbp)
callq 0x2350
movq -0x70(%rbp), %rdx
leaq 0x8b6c(%rip), %rsi      # 0x1f86c
leaq -0x48(%rbp), %rdi
callq 0x2290
jmp 0x16d0b
movq -0x68(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x15400
jmp 0x16d1a
leaq -0x48(%rbp), %rdi
callq 0x2130
leaq -0x49(%rbp), %rdi
callq 0x21e0
jmp 0x16d5c
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
jmp 0x16d51
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x58(%rbp)
movl %eax, -0x5c(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x2130
leaq -0x49(%rbp), %rdi
callq 0x21e0
jmp 0x16d71
jmp 0x16d67
movq -0x68(%rbp), %rdi
callq 0x15110
jmp 0x16d69
jmp 0x16d6b
addq $0x70, %rsp
popq %rbp
retq
movq -0x58(%rbp), %rdi
callq 0x2340
nopw (%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x5098, %rdi           # imm = 0x5098
leaq 0x8b0e(%rip), %rsi      # 0x1f8b0
callq 0x2280
movq -0x10(%rbp), %rdi
callq 0x15310
movq -0x10(%rbp), %rdi
addq $0x5050, %rdi           # imm = 0x5050
leaq 0x857a(%rip), %rsi      # 0x1f33c
callq 0x10ea0
testb $0x1, %al
jne 0x16dcd
jmp 0x16de2
movq -0x10(%rbp), %rdi
movl $0x0, 0x4dd4(%rdi)
callq 0x14f20
jmp 0x16e3a
movq -0x10(%rbp), %rdi
addq $0x5050, %rdi           # imm = 0x5050
leaq 0x8a1d(%rip), %rsi      # 0x1f811
callq 0x10ea0
testb $0x1, %al
jne 0x16e1a
movq -0x10(%rbp), %rdi
addq $0x5050, %rdi           # imm = 0x5050
leaq 0x8535(%rip), %rsi      # 0x1f344
callq 0x10ea0
testb $0x1, %al
jne 0x16e1a
jmp 0x16e2f
movq -0x10(%rbp), %rdi
movl $0x1, 0x4dd4(%rdi)
callq 0x14f20
jmp 0x16e38
movq -0x10(%rbp), %rdi
callq 0x15110
jmp 0x16e3a
addq $0x10, %rsp
popq %rbp
retq
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x5098, %rdi           # imm = 0x5098
leaq 0x85b1(%rip), %rsi      # 0x1f8b3
callq 0x2280
movq -0x10(%rbp), %rdi
callq 0x15310
movq -0x10(%rbp), %rdi
addq $0x5050, %rdi           # imm = 0x5050
leaq 0x8056(%rip), %rsi      # 0x1f378
callq 0x10ea0
testb $0x1, %al
jne 0x1732d
jmp 0x1738a
movq -0x10(%rbp), %rdi
movq %rdi, %rax
addq $0x2030, %rax           # imm = 0x2030
movslq 0x2028(%rdi), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl 0x4(%rax), %ecx
movslq 0x4d88(%rdi), %rax
movl %ecx, 0x4d38(%rdi,%rax,4)
movslq 0x4d88(%rdi), %rax
movl $0x0, 0x4d60(%rdi,%rax,4)
movl 0x4d88(%rdi), %eax
addl $0x1, %eax
movl %eax, 0x4d88(%rdi)
callq 0x173a0
movq -0x10(%rbp), %rdi
callq 0x17420
jmp 0x17393
movq -0x10(%rbp), %rdi
callq 0x15110
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x5098, %rdi           # imm = 0x5098
leaq 0x8676(%rip), %rsi      # 0x1fa38
callq 0x2280
movq -0x10(%rbp), %rdi
callq 0x15310
movq -0x10(%rbp), %rdi
addq $0x5050, %rdi           # imm = 0x5050
leaq 0x7f96(%rip), %rsi      # 0x1f378
callq 0x10ea0
testb $0x1, %al
jne 0x173ed
jmp 0x17416
movq -0x10(%rbp), %rdi
movq %rdi, %rax
addq $0x2030, %rax           # imm = 0x2030
movslq 0x2028(%rdi), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
movl %eax, 0x4ddc(%rdi)
callq 0x14f20
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x5098, %rdi           # imm = 0x5098
leaq 0x8474(%rip), %rsi      # 0x1f8b6
callq 0x2280
movq -0x10(%rbp), %rdi
callq 0x15310
movq -0x10(%rbp), %rdi
addq $0x5050, %rdi           # imm = 0x5050
leaq 0x7f03(%rip), %rsi      # 0x1f365
callq 0x10ea0
testb $0x1, %al
jne 0x1746d
jmp 0x174d9
movq -0x10(%rbp), %rdi
movslq 0x71ec(%rdi), %rax
movl 0x71c4(%rdi,%rax,4), %ecx
addl $0x1, %ecx
movl %ecx, 0x71c4(%rdi,%rax,4)
callq 0x14f20
movq -0x10(%rbp), %rdi
movq %rdi, %rax
addq $0x2030, %rax           # imm = 0x2030
movslq 0x2028(%rdi), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl 0x4(%rax), %ecx
movslq 0x4d88(%rdi), %rax
movl %ecx, 0x4d38(%rdi,%rax,4)
movl 0x4d88(%rdi), %eax
addl $0x1, %eax
movl %eax, 0x4d88(%rdi)
callq 0x173a0
movq -0x10(%rbp), %rdi
callq 0x17420
jmp 0x174db
jmp 0x174db
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x5098, %rdi           # imm = 0x5098
leaq 0x852c(%rip), %rsi      # 0x1fa3e
callq 0x2280
movq -0x10(%rbp), %rdi
callq 0x15310
movq -0x10(%rbp), %rdi
addq $0x5050, %rdi           # imm = 0x5050
leaq 0x7e46(%rip), %rsi      # 0x1f378
callq 0x10ea0
testb $0x1, %al
jne 0x1753d
jmp 0x17568
movq -0x10(%rbp), %rdi
movq %rdi, %rax
addq $0x2030, %rax           # imm = 0x2030
movslq 0x2028(%rdi), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl 0x4(%rax), %eax
movl %eax, 0x4ddc(%rdi)
callq 0x14f20
jmp 0x17571
movq -0x10(%rbp), %rdi
callq 0x15110
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x5098, %rdi           # imm = 0x5098
leaq 0x8398(%rip), %rsi      # 0x1f93a
callq 0x2280
movq -0x10(%rbp), %rdi
callq 0x15310
movq -0x10(%rbp), %rdi
addq $0x5050, %rdi           # imm = 0x5050
leaq 0x7dad(%rip), %rsi      # 0x1f36f
callq 0x10ea0
testb $0x1, %al
jne 0x17603
movq -0x10(%rbp), %rdi
addq $0x5050, %rdi           # imm = 0x5050
leaq 0x7a62(%rip), %rsi      # 0x1f03f
callq 0x10ea0
testb $0x1, %al
jne 0x17603
movq -0x10(%rbp), %rdi
addq $0x5050, %rdi           # imm = 0x5050
leaq 0x7d5f(%rip), %rsi      # 0x1f357
callq 0x10ea0
testb $0x1, %al
jne 0x17603
jmp 0x17608
jmp 0x17764
movq -0x10(%rbp), %rdi
addq $0x5050, %rdi           # imm = 0x5050
leaq 0x7a55(%rip), %rsi      # 0x1f06f
callq 0x10ea0
testb $0x1, %al
jne 0x17625
jmp 0x17633
movq -0x10(%rbp), %rdi
callq 0x17770
jmp 0x17762
movq -0x10(%rbp), %rdi
addq $0x5050, %rdi           # imm = 0x5050
leaq 0x7d07(%rip), %rsi      # 0x1f34c
callq 0x10ea0
testb $0x1, %al
jne 0x17650
jmp 0x1765e
movq -0x10(%rbp), %rdi
callq 0x17880
jmp 0x17760
movq -0x10(%rbp), %rdi
addq $0x5050, %rdi           # imm = 0x5050
leaq 0x7a1c(%rip), %rsi      # 0x1f08c
callq 0x10ea0
testb $0x1, %al
jne 0x1767b
jmp 0x17689
movq -0x10(%rbp), %rdi
callq 0x178c0
jmp 0x1775e
movq -0x10(%rbp), %rdi
addq $0x5050, %rdi           # imm = 0x5050
leaq 0x7cdd(%rip), %rsi      # 0x1f378
callq 0x10ea0
testb $0x1, %al
jne 0x176a6
jmp 0x176b4
movq -0x10(%rbp), %rdi
callq 0x179d0
jmp 0x1775c
movq -0x10(%rbp), %rdi
addq $0x5050, %rdi           # imm = 0x5050
leaq 0x7957(%rip), %rsi      # 0x1f01d
callq 0x10ea0
testb $0x1, %al
jne 0x176d1
jmp 0x176dc
movq -0x10(%rbp), %rdi
callq 0x17af0
jmp 0x1775a
movq -0x10(%rbp), %rdi
addq $0x5050, %rdi           # imm = 0x5050
leaq 0x7c63(%rip), %rsi      # 0x1f351
callq 0x10ea0
testb $0x1, %al
jne 0x176f9
jmp 0x17704
movq -0x10(%rbp), %rdi
callq 0x17d20
jmp 0x17758
movq -0x10(%rbp), %rdi
addq $0x5050, %rdi           # imm = 0x5050
leaq 0x7c3e(%rip), %rsi      # 0x1f354
callq 0x10ea0
testb $0x1, %al
jne 0x17721
jmp 0x1772c
movq -0x10(%rbp), %rdi
callq 0x17fe0
jmp 0x17756
movq -0x10(%rbp), %rdi
addq $0x5050, %rdi           # imm = 0x5050
leaq 0x7bf4(%rip), %rsi      # 0x1f332
callq 0x10ea0
testb $0x1, %al
jne 0x17749
jmp 0x1774b
jmp 0x17754
movq -0x10(%rbp), %rdi
callq 0x15110
jmp 0x17756
jmp 0x17758
jmp 0x1775a
jmp 0x1775c
jmp 0x1775e
jmp 0x17760
jmp 0x17762
jmp 0x17764
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0x5098, %rdi           # imm = 0x5098
leaq 0x8186(%rip), %rsi      # 0x1f918
callq 0x2280
movq -0x48(%rbp), %rdi
callq 0x15310
movq -0x48(%rbp), %rdi
addq $0x5050, %rdi           # imm = 0x5050
leaq 0x78bd(%rip), %rsi      # 0x1f06f
callq 0x10ea0
testb $0x1, %al
jne 0x177c0
jmp 0x1786c
movq -0x48(%rbp), %rdi
callq 0x14f20
movq -0x48(%rbp), %rdi
callq 0x182a0
movq -0x48(%rbp), %rax
addq $0x50c0, %rax           # imm = 0x50C0
movq %rax, -0x58(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x2350
movq -0x50(%rbp), %rdx
leaq 0x8123(%rip), %rsi      # 0x1f91b
leaq -0x28(%rbp), %rdi
callq 0x2290
jmp 0x17803
movq -0x58(%rbp), %rdi
movq -0x48(%rbp), %rax
movl 0x71f0(%rax), %edx
leaq -0x28(%rbp), %rsi
callq 0x12f70
jmp 0x1781c
leaq -0x28(%rbp), %rdi
callq 0x2130
leaq -0x29(%rbp), %rdi
callq 0x21e0
movq -0x48(%rbp), %rax
movl $0x0, 0x71f0(%rax)
jmp 0x1786e
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x17861
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2130
leaq -0x29(%rbp), %rdi
callq 0x21e0
jmp 0x17874
jmp 0x1786e
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x2340
nopl (%rax)
// File: navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::WriteStat()
void Parse::WriteStat()//write statement
{where="WS";check();
   if(LHS=="write")
   {
      match();
      ExpList();
      gen.emit2("WRITE", tempSizeWrite);
      tempSizeWrite = 0;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0x5098, %rdi           # imm = 0x5098
leaq 0x8047(%rip), %rsi      # 0x1f929
callq 0x2280
movq -0x48(%rbp), %rdi
callq 0x15310
movq -0x48(%rbp), %rdi
addq $0x5050, %rdi           # imm = 0x5050
leaq 0x778a(%rip), %rsi      # 0x1f08c
callq 0x10ea0
testb $0x1, %al
jne 0x17910
jmp 0x179bc
movq -0x48(%rbp), %rdi
callq 0x14f20
movq -0x48(%rbp), %rdi
callq 0x186f0
movq -0x48(%rbp), %rax
addq $0x50c0, %rax           # imm = 0x50C0
movq %rax, -0x58(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x2350
movq -0x50(%rbp), %rdx
leaq 0x7fe4(%rip), %rsi      # 0x1f92c
leaq -0x28(%rbp), %rdi
callq 0x2290
jmp 0x17953
movq -0x58(%rbp), %rdi
movq -0x48(%rbp), %rax
movl 0x71f4(%rax), %edx
leaq -0x28(%rbp), %rsi
callq 0x12f70
jmp 0x1796c
leaq -0x28(%rbp), %rdi
callq 0x2130
leaq -0x29(%rbp), %rdi
callq 0x21e0
movq -0x48(%rbp), %rax
movl $0x0, 0x71f4(%rax)
jmp 0x179bc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x179b1
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2130
leaq -0x29(%rbp), %rdi
callq 0x21e0
jmp 0x179c2
addq $0x60, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x2340
nopl (%rax,%rax)
// File: navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::AsnStat()
void Parse::AsnStat()//assignment statement
{where="AS";check();
 
   VarAcList();
   
   if(LHS==":=")
   {
      match();
      ExpList();
   }else
      errorReport();
   gen.emit2("ASSIGN", tempSizeAsn);
   
   tempSizeAsn = 0;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x48(%rbp)
addq $0x5098, %rdi           # imm = 0x5098
leaq 0x7f47(%rip), %rsi      # 0x1f939
callq 0x2280
movq -0x48(%rbp), %rdi
callq 0x15310
movq -0x48(%rbp), %rdi
callq 0x182a0
movq -0x48(%rbp), %rdi
addq $0x5050, %rdi           # imm = 0x5050
leaq 0x7957(%rip), %rsi      # 0x1f372
callq 0x10ea0
testb $0x1, %al
jne 0x17a26
jmp 0x17a3a
movq -0x48(%rbp), %rdi
callq 0x14f20
movq -0x48(%rbp), %rdi
callq 0x186f0
jmp 0x17a43
movq -0x48(%rbp), %rdi
callq 0x15110
movq -0x48(%rbp), %rax
addq $0x50c0, %rax           # imm = 0x50C0
movq %rax, -0x58(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x2350
movq -0x50(%rbp), %rdx
leaq 0x7ed3(%rip), %rsi      # 0x1f93c
leaq -0x28(%rbp), %rdi
callq 0x2290
jmp 0x17a74
movq -0x58(%rbp), %rdi
movq -0x48(%rbp), %rax
movl 0x71f8(%rax), %edx
leaq -0x28(%rbp), %rsi
callq 0x12f70
jmp 0x17a8d
leaq -0x28(%rbp), %rdi
callq 0x2130
leaq -0x29(%rbp), %rdi
callq 0x21e0
movq -0x48(%rbp), %rax
movl $0x0, 0x71f8(%rax)
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x17ad6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2130
leaq -0x29(%rbp), %rdi
callq 0x21e0
movq -0x38(%rbp), %rdi
callq 0x2340
nopl (%rax,%rax)