LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::StatPtr()
void Parse::StatPtr()//statement part
{where="SP";check();

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

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x5098(%rdi), %r15
leaq 0x5050(%rdi), %r14
leaq 0x605c(%rip), %r13      # 0x132c8
leaq 0x5070(%rdi), %r12
movq 0x50a0(%rbx), %rdx
movl $0x2, %r8d
movq %r15, %rdi
xorl %esi, %esi
leaq 0x6536(%rip), %rcx      # 0x137c2
callq 0x22b0
movq %rbx, %rdi
callq 0xc41a
movq %rbx, %rdi
callq 0xe28e
movq %r14, %rdi
movq %r13, %rsi
callq 0x2080
testl %eax, %eax
jne 0xd2d9
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 0xd273
leaq 0x604e(%rip), %rsi      # 0x1332e
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xd33b
leaq 0x6087(%rip), %rsi      # 0x1337a
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xd33b
leaq 0x6057(%rip), %rsi      # 0x1335d
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xd33b
leaq 0x6047(%rip), %rsi      # 0x13360
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xd33b
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xc1be
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x645c(%rip), %rcx      # 0x137cb
movl $0x1, %r8d
xorl %esi, %esi
callq 0x22b0
movq %rbx, %rdi
callq 0xc41a
leaq 0x5050(%rbx), %r14
leaq 0x5fa0(%rip), %rsi      # 0x13332
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xd44f
leaq 0x5f8f(%rip), %rsi      # 0x13338
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xd404
leaq 0x6302(%rip), %rsi      # 0x136be
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xd404
leaq 0x5f71(%rip), %rsi      # 0x13340
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xd404
leaq 0x5c45(%rip), %rsi      # 0x13027
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xd4b7
movq %rbx, %rdi
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xc1be
movq %rbx, %rdi
callq 0xd5da
movq %rbx, %rdi
callq 0xc774
testb %al, %al
jne 0xd4ac
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x62bc(%rip), %rsi      # 0x136e7
leaq 0x62dc(%rip), %rdx      # 0x1370e
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x42dc
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc53c
movq -0x38(%rbp), %rdi
jmp 0xd4a2
movslq 0x71ec(%rbx), %rax
incl 0x71c4(%rbx,%rax,4)
movq %rbx, %rdi
callq 0xd4f0
movq %rbx, %rdi
callq 0xc670
testb %al, %al
jne 0xd4ac
leaq -0x48(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x6246(%rip), %rsi      # 0x136c6
leaq 0x625f(%rip), %rdx      # 0x136e6
leaq -0x58(%rbp), %r14
movq %r14, %rdi
callq 0x42dc
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc53c
movq -0x58(%rbp), %rdi
cmpq %r15, %rdi
je 0xd4ac
callq 0x21b0
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
incl 0x71ec(%rbx)
movq %rbx, %rdi
callq 0xd682
decl 0x71ec(%rbx)
jmp 0xd4ac
movq %rax, %rbx
movq -0x58(%rbp), %rdi
jmp 0xd4dd
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0xd4e7
callq 0x21b0
movq %rbx, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x61fd(%rip), %rcx      # 0x1370f
movl $0x2, %r8d
xorl %esi, %esi
callq 0x22b0
movq %rbx, %rdi
callq 0xc41a
leaq 0x5050(%rbx), %r14
leaq 0x5dfd(%rip), %rsi      # 0x13332
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
jne 0xd595
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 0xd990
leaq 0x5df5(%rip), %rsi      # 0x1337e
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xd5a0
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 0xda32
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x6119(%rip), %rcx      # 0x13712
movl $0x2, %r8d
xorl %esi, %esi
callq 0x22b0
movq %rbx, %rdi
callq 0xc41a
movl $0x0, 0x4d88(%rbx)
leaq 0x5050(%rbx), %r14
leaq 0x6098(%rip), %rsi      # 0x136be
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xd664
leaq 0x5d07(%rip), %rsi      # 0x13340
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xd664
leaq 0x5cec(%rip), %rsi      # 0x13338
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xd664
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xc1be
movl $0x1, 0x4dd8(%rbx)
movq %rbx, %rdi
callq 0xdbc0
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xdc86
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5f39(%rip), %rcx      # 0x138e8
movl $0x2, %r8d
xorl %esi, %esi
callq 0x22b0
movq %rbx, %rdi
callq 0xc41a
leaq 0x5050(%rbx), %r14
leaq 0x582d(%rip), %rsi      # 0x131ff
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xd9ea
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xc1be
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_O1/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 0x5dd9(%rip), %rcx      # 0x13830
movl $0x1, %r8d
xorl %esi, %esi
callq 0x22b0
movq %rbx, %rdi
callq 0xc41a
movl $0x0, 0x4dd8(%rbx)
leaq 0x5050(%rbx), %r14
leaq 0x583c(%rip), %rsi      # 0x132c0
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xdaf7
leaq 0x58d2(%rip), %rsi      # 0x13369
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xdadb
leaq 0x58b9(%rip), %rsi      # 0x13363
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xdadb
leaq 0x5742(%rip), %rsi      # 0x131ff
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xdb13
movq %rbx, %rdi
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xc1be
movl $0x1, 0x4dd4(%rbx)
movq %rbx, %rdi
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x10314
movl $0x0, 0x4dd4(%rbx)
movq %rbx, %rdi
addq $0x48, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1026c
movq %rbx, %rdi
callq 0xd990
leaq 0x4c38(%rbx), %rsi
movl 0x4ddc(%rbx), %edx
leaq -0x54(%rbp), %r14
movq %r14, %rdi
callq 0x109c6
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 0xdb9b
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x5baa(%rip), %rsi      # 0x13719
leaq 0x5bc8(%rip), %rdx      # 0x1373e
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x42dc
movq %rbx, %rdi
movq %r14, %rsi
callq 0xc53c
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0xdb9b
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 0xdbb7
callq 0x21b0
movq %rbx, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5b7e(%rip), %rcx      # 0x1375d
movl $0x2, %r8d
xorl %esi, %esi
callq 0x22b0
movq %rbx, %rdi
callq 0xc41a
leaq 0x5050(%rbx), %r14
leaq 0x5736(%rip), %rsi      # 0x13338
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xdc4c
leaq 0x5aa9(%rip), %rsi      # 0x136be
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xdc40
leaq 0x5718(%rip), %rsi      # 0x13340
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xdc40
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xc1be
movl $0x1, 0x4dd4(%rbx)
jmp 0xdc56
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_O1/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 0x576e(%rip), %rcx      # 0x13760
movl $0x2, %r8d
xorl %esi, %esi
callq 0x22b0
movq %rbx, %rdi
callq 0xc41a
leaq 0x5050(%rbx), %rdi
leaq 0x51ea(%rip), %rsi      # 0x131ff
callq 0x2080
testl %eax, %eax
je 0xe02c
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xc1be
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 0xe07a
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xe110
// File: /workspace/github_cpp_makefile_star2_O1/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 0x584c(%rip), %rcx      # 0x138e5
movl $0x2, %r8d
xorl %esi, %esi
callq 0x22b0
movq %rbx, %rdi
callq 0xc41a
leaq 0x5050(%rbx), %r14
leaq 0x5143(%rip), %rsi      # 0x131ff
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
jne 0xe10b
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_O1/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::VarListB()
void Parse::VarListB()//variable list for multiple itiretions
{where="VLB";check();
   if(LHS==",")
   {
      valLength[valLenPtr]++;
      match();
      //cout<<ln[tokeNum][1]<<where;
      varListIndex[listDepth] = ln[tokeNum][1];
      listDepth++;
      VarName();
      VarListB();
   }else
   {
      
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x5098(%rdi), %r14
leaq 0x5050(%rdi), %r12
leaq 0x523a(%rip), %r13      # 0x13370
leaq 0x5070(%rdi), %r15
movq 0x50a0(%rbx), %rdx
movl $0x3, %r8d
movq %r14, %rdi
xorl %esi, %esi
leaq 0x560d(%rip), %rcx      # 0x13763
callq 0x22b0
movq %rbx, %rdi
callq 0xc41a
movq %r12, %rdi
movq %r13, %rsi
callq 0x2080
testl %eax, %eax
jne 0xe1dd
movslq 0x71ec(%rbx), %rax
incl 0x71c4(%rbx,%rax,4)
movq %r15, %rdi
movq %r12, %rsi
callq 0x2100
movslq 0x2028(%rbx), %rsi
shlq $0x5, %rsi
addq %rbx, %rsi
movq %r12, %rdi
callq 0x2100
movslq 0x2028(%rbx), %rax
leal 0x1(%rax), %ecx
movl %ecx, 0x2028(%rbx)
leaq (%rax,%rax,2), %rax
movl 0x2040(%rbx,%rax,4), %eax
movslq 0x4d88(%rbx), %rcx
movl %eax, 0x4d38(%rbx,%rcx,4)
incl 0x4d88(%rbx)
movq %rbx, %rdi
callq 0xe07a
jmp 0xe13d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x56e0(%rip), %rcx      # 0x138eb
movl $0x2, %r8d
xorl %esi, %esi
callq 0x22b0
movq %rbx, %rdi
callq 0xc41a
leaq 0x5050(%rbx), %r14
leaq 0x4fd1(%rip), %rsi      # 0x131ff
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xe246
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xc1be
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_O1/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 0x553a(%rip), %rcx      # 0x137e7
movl $0x1, %r8d
xorl %esi, %esi
callq 0x22b0
movq %rbx, %rdi
callq 0xc41a
leaq 0x5050(%rbx), %r14
leaq 0x50aa(%rip), %rsi      # 0x1337a
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xe3c2
leaq 0x5076(%rip), %rsi      # 0x1335d
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xe3c2
leaq 0x5062(%rip), %rsi      # 0x13360
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xe3c2
leaq 0x5038(%rip), %rsi      # 0x1334d
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xe3c7
leaq 0x501c(%rip), %rsi      # 0x13348
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xe3d3
leaq 0x4d1c(%rip), %rsi      # 0x1305f
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xe3df
leaq 0x4ea5(%rip), %rsi      # 0x131ff
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xe3eb
leaq 0x4fe1(%rip), %rsi      # 0x13352
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xe3f7
leaq 0x4fd3(%rip), %rsi      # 0x13357
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xe403
leaq 0x4fc3(%rip), %rsi      # 0x1335a
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xe40f
leaq 0x4f84(%rip), %rsi      # 0x1332e
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xe3c2
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xc1be
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xe41c
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xe51a
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xe586
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xe684
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xe790
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xe928
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xeb52
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x5384(%rip), %rcx      # 0x137c5
movl $0x2, %r8d
xorl %esi, %esi
callq 0x22b0
movq %rbx, %rdi
callq 0xc41a
leaq 0x5050(%rbx), %r14
leaq 0x4ee9(%rip), %rsi      # 0x1334d
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
jne 0xe4f6
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 0xed68
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x5312(%rip), %rsi      # 0x137c8
leaq 0x530f(%rip), %rdx      # 0x137cc
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x42dc
leaq 0x50c0(%rbx), %rdi
movl 0x71f0(%rbx), %edx
movq %r14, %rsi
callq 0xab04
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0xe4ec
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 0xe512
callq 0x21b0
movq %rbx, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
addq $0x5098, %rdi           # imm = 0x5098
movq 0x50a0(%rbx), %rdx
leaq 0x522b(%rip), %rcx      # 0x137d6
movl $0x2, %r8d
xorl %esi, %esi
callq 0x22b0
movq %rbx, %rdi
callq 0xc41a
leaq 0x5050(%rbx), %r14
leaq 0x4a91(%rip), %rsi      # 0x1305f
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
jne 0xe660
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 0xf08a
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x51b9(%rip), %rsi      # 0x137d9
leaq 0x51b7(%rip), %rdx      # 0x137de
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x42dc
leaq 0x50c0(%rbx), %rdi
movl 0x71f4(%rbx), %edx
movq %r14, %rsi
callq 0xab04
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0xe656
callq 0x21b0
movl $0x0, 0x71f4(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0xe67c
callq 0x21b0
movq %rbx, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
addq $0x5098, %rdi           # imm = 0x5098
movq 0x50a0(%rbx), %rdx
leaq 0x513d(%rip), %rcx      # 0x137e6
movl $0x2, %r8d
xorl %esi, %esi
callq 0x22b0
movq %rbx, %rdi
callq 0xc41a
movq %rbx, %rdi
callq 0xed68
leaq 0x5050(%rbx), %r14
leaq 0x4ca9(%rip), %rsi      # 0x1337d
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xe6ea
movq %rbx, %rdi
callq 0xc1be
jmp 0xe71d
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 0xf08a
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x50bd(%rip), %rsi      # 0x137e9
leaq 0x50bc(%rip), %rdx      # 0x137ef
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x42dc
leaq 0x50c0(%rbx), %rdi
movl 0x71f8(%rbx), %edx
movq %r14, %rsi
callq 0xab04
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0xe762
callq 0x21b0
movl $0x0, 0x71f8(%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0xe788
callq 0x21b0
movq %rbx, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O1/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::ProcStat()
void Parse::ProcStat()//procedure statement
{where="PS";check();
   if(LHS=="call")
   {
      match();      
      ProcName();
            if(!bTable.search(index))
	 scopeError("Procedure Not Defined in ProcStat");

      ent = bTable.find_all_level(index);
      //cout<<endl<<ln[tokeNum-1][0]<<", with label";
      //cout<<" "<<ent.procLabel<<", ";
      gen.emit3("CALL", bTable.loc(index), ent.procLabel);

      
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x60, %rsp
movq %rdi, %rbx
addq $0x5098, %rdi           # imm = 0x5098
movq 0x50a0(%rbx), %rdx
leaq 0x5039(%rip), %rcx      # 0x137f0
movl $0x2, %r8d
xorl %esi, %esi
callq 0x22b0
movq %rbx, %rdi
callq 0xc41a
leaq 0x5050(%rbx), %r14
leaq 0x4b78(%rip), %rsi      # 0x13352
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
jne 0xe8f4
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 0xe1ec
leaq 0x4c38(%rbx), %r14
movl 0x4ddc(%rbx), %esi
movq %r14, %rdi
callq 0x10458
testb %al, %al
jne 0xe872
leaq -0x50(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x4fad(%rip), %rsi      # 0x137f3
leaq 0x4fc7(%rip), %rdx      # 0x13814
leaq -0x60(%rbp), %r15
movq %r15, %rdi
callq 0x42dc
movq %rbx, %rdi
movq %r15, %rsi
callq 0xc53c
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0xe872
callq 0x21b0
movl 0x4ddc(%rbx), %edx
leaq -0x7c(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x109c6
movups (%r15), %xmm0
movups 0xc(%r15), %xmm1
movups %xmm1, 0x4e1c(%rbx)
movups %xmm0, 0x4e10(%rbx)
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x4f68(%rip), %rsi      # 0x13815
leaq 0x4f65(%rip), %rdx      # 0x13819
leaq -0x40(%rbp), %rdi
callq 0x42dc
movl 0x4ddc(%rbx), %esi
movq %r14, %rdi
callq 0x1095e
movl 0x4e28(%rbx), %ecx
addq $0x50c0, %rbx           # imm = 0x50C0
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
movl %eax, %edx
callq 0xabb8
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0xe8f4
callq 0x21b0
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
jne 0xe91b
jmp 0xe920
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0xe920
callq 0x21b0
movq %rbx, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O1/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::IfStat()
void Parse::IfStat()//if statements
{where="IS";check();

   match();
   int startL = newLabel(), doneL= newLabel(), pass1 = startL, pass2 = doneL;
   GarCmdList(pass1, pass2);
   gen.emit2("DEFADDR", startL);
   if(LHS=="fi")
   {
      gen.emit2("FI", ln[tokeNum][0]);
      match();
      gen.emit2("DEFADDR", doneL);
   }else
      errorReport();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
addq $0x5098, %rdi           # imm = 0x5098
movq 0x50a0(%rbx), %rdx
leaq 0x4ec6(%rip), %rcx      # 0x1381a
movl $0x2, %r8d
xorl %esi, %esi
callq 0x22b0
movq %rbx, %rdi
callq 0xc41a
leaq 0x5050(%rbx), %r14
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, -0x40(%rbp)
movq %r14, %rdi
callq 0x2100
incl 0x2028(%rbx)
movl 0x71b0(%rbx), %r14d
leal 0x1(%r14), %r12d
addl $0x2, %r14d
movl %r14d, 0x71b0(%rbx)
leaq -0x44(%rbp), %rsi
movl %r12d, (%rsi)
movq %rbx, %rdi
movl %r14d, %edx
callq 0xf1de
leaq 0x50c0(%rbx), %r15
leaq -0x58(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0x4cd2(%rip), %rsi      # 0x136b3
leaq 0x4cd2(%rip), %rdx      # 0x136ba
leaq -0x68(%rbp), %r13
movq %r13, %rdi
callq 0x42dc
movq %r15, -0x30(%rbp)
movq %r15, %rdi
movq %r13, %rsi
movl %r12d, %edx
callq 0xab04
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0xea18
callq 0x21b0
leaq 0x493e(%rip), %rsi      # 0x1335d
movq -0x40(%rbp), %r15
movq %r15, %rdi
callq 0x2080
testl %eax, %eax
je 0xea3c
movq %rbx, %rdi
callq 0xc1be
jmp 0xeb00
leaq -0x98(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x4dcf(%rip), %rsi      # 0x1381d
leaq 0x4dca(%rip), %rdx      # 0x1381f
leaq -0xa8(%rbp), %r12
movq %r12, %rdi
callq 0x42dc
movslq 0x2028(%rbx), %rax
leaq (%rax,%rax,2), %rax
movl 0x2030(%rbx,%rax,4), %edx
movq -0x30(%rbp), %rdi
movq %r12, %rsi
callq 0xab04
movq -0xa8(%rbp), %rdi
cmpq %r13, %rdi
je 0xea93
callq 0x21b0
movq -0x38(%rbp), %rdi
movq %r15, %rsi
callq 0x2100
movslq 0x2028(%rbx), %rsi
shlq $0x5, %rsi
addq %rbx, %rsi
movq %r15, %rdi
callq 0x2100
incl 0x2028(%rbx)
leaq -0x78(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x4be9(%rip), %rsi      # 0x136b3
leaq 0x4be9(%rip), %rdx      # 0x136ba
leaq -0x88(%rbp), %rbx
movq %rbx, %rdi
callq 0x42dc
movq -0x30(%rbp), %rdi
movq %rbx, %rsi
movl %r14d, %edx
callq 0xab04
movq -0x88(%rbp), %rdi
cmpq %r15, %rdi
je 0xeb00
callq 0x21b0
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x88(%rbp), %rdi
cmpq %r15, %rdi
jne 0xeb44
jmp 0xeb49
movq %rax, %rbx
movq -0xa8(%rbp), %rdi
cmpq %r13, %rdi
jne 0xeb44
jmp 0xeb49
movq %rax, %rbx
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0xeb49
callq 0x21b0
movq %rbx, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O1/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::DoStat()
void Parse::DoStat()//do statement
{where="DS";check();
   int startL = newLabel(), loopL= newLabel(), pass1 = startL, pass2 = loopL;
   
   match();
   gen.emit2("DEFADDR", loopL);
   GarCmdList(pass1, pass2);
   if(LHS=="od")
   {
      gen.emit2("OD", ln[tokeNum][0]);
      match();
       gen.emit2("DEFADDR", startL);
   }else
	 errorReport();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdi, %rbx
addq $0x5098, %rdi           # imm = 0x5098
movq 0x50a0(%rbx), %rdx
leaq 0x4ca5(%rip), %rcx      # 0x13820
movl $0x2, %r8d
xorl %esi, %esi
callq 0x22b0
movq %rbx, %rdi
callq 0xc41a
movl 0x71b0(%rbx), %r14d
leal 0x1(%r14), %eax
addl $0x2, %r14d
movl %r14d, 0x71b0(%rbx)
movl %eax, -0x2c(%rbp)
movl %eax, -0x30(%rbp)
leaq 0x5050(%rbx), %r15
leaq 0x5070(%rbx), %rdi
movq %rdi, -0x40(%rbp)
movq %r15, %rsi
callq 0x2100
movslq 0x2028(%rbx), %rsi
shlq $0x5, %rsi
addq %rbx, %rsi
movq %r15, %rdi
callq 0x2100
incl 0x2028(%rbx)
leaq 0x50c0(%rbx), %r12
leaq -0x50(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0x4abb(%rip), %rsi      # 0x136b3
leaq 0x4abb(%rip), %rdx      # 0x136ba
leaq -0x60(%rbp), %r13
movq %r13, %rdi
callq 0x42dc
movq %r12, -0x38(%rbp)
movq %r12, %rdi
movq %r13, %rsi
movl %r14d, %edx
callq 0xab04
movq -0x60(%rbp), %rdi
leaq -0x50(%rbp), %rax
cmpq %rax, %rdi
je 0xec2f
callq 0x21b0
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
movl %r14d, %edx
callq 0xf1de
leaq 0x471b(%rip), %rsi      # 0x13360
movq %r15, %rdi
callq 0x2080
testl %eax, %eax
je 0xec5e
movq %rbx, %rdi
callq 0xc1be
jmp 0xed1c
leaq -0x90(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x4bb3(%rip), %rsi      # 0x13823
leaq 0x4bae(%rip), %rdx      # 0x13825
leaq -0xa0(%rbp), %r14
movq %r14, %rdi
callq 0x42dc
movslq 0x2028(%rbx), %rax
leaq (%rax,%rax,2), %rax
movl 0x2030(%rbx,%rax,4), %edx
movq -0x38(%rbp), %rdi
movq %r14, %rsi
callq 0xab04
movq -0xa0(%rbp), %rdi
cmpq %r13, %rdi
je 0xecb5
callq 0x21b0
movq -0x40(%rbp), %rdi
movq %r15, %rsi
callq 0x2100
movslq 0x2028(%rbx), %rsi
shlq $0x5, %rsi
addq %rbx, %rsi
movq %r15, %rdi
callq 0x2100
incl 0x2028(%rbx)
leaq -0x70(%rbp), %r14
movq %r14, -0x10(%r14)
leaq 0x49c7(%rip), %rsi      # 0x136b3
leaq 0x49c7(%rip), %rdx      # 0x136ba
leaq -0x80(%rbp), %rbx
movq %rbx, %rdi
callq 0x42dc
movq -0x38(%rbp), %rdi
movq %rbx, %rsi
movl -0x2c(%rbp), %edx
callq 0xab04
movq -0x80(%rbp), %rdi
cmpq %r14, %rdi
je 0xed1c
callq 0x21b0
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x80(%rbp), %rdi
cmpq %r14, %rdi
jne 0xed5a
jmp 0xed5f
movq %rax, %rbx
movq -0xa0(%rbp), %rdi
cmpq %r13, %rdi
jne 0xed5a
jmp 0xed5f
movq %rax, %rbx
movq -0x60(%rbp), %rdi
leaq -0x50(%rbp), %rax
cmpq %rax, %rdi
je 0xed5f
callq 0x21b0
movq %rbx, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O1/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::VarAcList()
void Parse::VarAcList()//variable access list
{where="VAL";check();
   if(LHS=="id")
   {
      tempSizeRead++;
      tempSizeAsn++;
      VarAc();
      VarAcListB();
   }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 0x4a47(%rip), %rcx      # 0x137cd
movl $0x3, %r8d
xorl %esi, %esi
callq 0x22b0
movq %rbx, %rdi
callq 0xc41a
leaq 0x5050(%rbx), %rdi
leaq 0x4456(%rip), %rsi      # 0x131ff
callq 0x2080
testl %eax, %eax
je 0xedc0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xc1be
incl 0x71f0(%rbx)
incl 0x71f8(%rbx)
movq %rbx, %rdi
callq 0xede2
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xefdc
// File: /workspace/github_cpp_makefile_star2_O1/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::VarAc()
void Parse::VarAc()//Variable access
{where="Va";check();
   
   if(LHS=="id")
   {

      VarName();
      ent = bTable.find_all_level(index);
      //cout<<endl<<ent.disp<<endl;
      gen.emit3("VARIABLE", bTable.loc(index), ent.disp);
      //cout << endl << "index: "<< ent.idindex << endl << endl;
      if(!bTable.search(index))
	 scopeError("list Variable not Defined in VarAc");
      VarAcB();
      if(ary == 1)
      {
	 gen.emit3("INDEX", ent.size, ln[tokeNum][0]);
	 ary = 0;
      }
   }else
      errorReport();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rdi, %rbx
addq $0x5098, %rdi           # imm = 0x5098
movq 0x50a0(%rbx), %rdx
leaq 0x4a9d(%rip), %rcx      # 0x138a9
movl $0x2, %r8d
xorl %esi, %esi
callq 0x22b0
movq %rbx, %rdi
callq 0xc41a
leaq 0x5050(%rbx), %rdi
leaq 0x43d0(%rip), %rsi      # 0x131ff
callq 0x2080
testl %eax, %eax
je 0xee4f
movq %rbx, %rdi
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xc1be
movq %rbx, %rdi
callq 0xe07a
leaq 0x4c38(%rbx), %r15
movl 0x4ddc(%rbx), %edx
leaq -0x9c(%rbp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x109c6
movups (%r14), %xmm0
movups 0xc(%r14), %xmm1
movups %xmm1, 0x4e1c(%rbx)
movups %xmm0, 0x4e10(%rbx)
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x4a0f(%rip), %rsi      # 0x138ac
leaq 0x4a10(%rip), %rdx      # 0x138b4
leaq -0x40(%rbp), %rdi
callq 0x42dc
movl 0x4ddc(%rbx), %esi
movq %r15, %rdi
callq 0x1095e
leaq 0x50c0(%rbx), %r14
movl 0x4e24(%rbx), %ecx
leaq -0x40(%rbp), %rsi
movq %r14, %rdi
movl %eax, %edx
callq 0xabb8
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0xeee4
callq 0x21b0
movl 0x4ddc(%rbx), %esi
movq %r15, %rdi
callq 0x10458
testb %al, %al
jne 0xef32
leaq -0x70(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x49af(%rip), %rsi      # 0x138b5
leaq 0x49ca(%rip), %rdx      # 0x138d7
leaq -0x80(%rbp), %r15
movq %r15, %rdi
callq 0x42dc
movq %rbx, %rdi
movq %r15, %rsi
callq 0xc53c
movq -0x80(%rbp), %rdi
cmpq %r12, %rdi
je 0xef32
callq 0x21b0
movq %rbx, %rdi
callq 0x10136
cmpl $0x1, 0x71b4(%rbx)
jne 0xefa1
leaq -0x50(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x4985(%rip), %rsi      # 0x138d8
leaq 0x4983(%rip), %rdx      # 0x138dd
leaq -0x60(%rbp), %r15
movq %r15, %rdi
callq 0x42dc
movl 0x4e1c(%rbx), %edx
movslq 0x2028(%rbx), %rax
leaq (%rax,%rax,2), %rax
movl 0x2030(%rbx,%rax,4), %ecx
movq %r14, %rdi
movq %r15, %rsi
callq 0xabb8
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0xef97
callq 0x21b0
movl $0x0, 0x71b4(%rbx)
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x60(%rbp), %rdi
jmp 0xefca
movq %rax, %rbx
movq -0x80(%rbp), %rdi
jmp 0xefca
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0xefd4
callq 0x21b0
movq %rbx, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O1/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::VarAcListB()
void Parse::VarAcListB()//variable access list for iterations
{where="VALB";check();
   if(LHS==",")
   {
      tempSizeRead++;
      tempSizeAsn++;
      match();
      
      VarAc();
      VarAcListB();
   }else
   {
      
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x5098(%rdi), %r14
leaq 0x5050(%rdi), %r12
leaq 0x436e(%rip), %r13      # 0x13370
leaq 0x5070(%rdi), %r15
movq 0x50a0(%rbx), %rdx
movl $0x4, %r8d
movq %r14, %rdi
xorl %esi, %esi
leaq 0x47af(%rip), %rcx      # 0x137d1
callq 0x22b0
movq %rbx, %rdi
callq 0xc41a
movq %r12, %rdi
movq %r13, %rsi
callq 0x2080
testl %eax, %eax
jne 0xf07b
incl 0x71f0(%rbx)
incl 0x71f8(%rbx)
movq %r15, %rdi
movq %r12, %rsi
callq 0x2100
movslq 0x2028(%rbx), %rsi
shlq $0x5, %rsi
addq %rbx, %rsi
movq %r12, %rdi
callq 0x2100
incl 0x2028(%rbx)
movq %rbx, %rdi
callq 0xede2
jmp 0xf009
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::ExpList()
void Parse::ExpList()//expression list
{where="EL";check();
   if(LHS!="-")
   {
      
      
   }
   tempSizeWrite++;
      Exp();
      ExpListB();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x5098, %rdi           # imm = 0x5098
movq 0x50a0(%rbx), %rdx
leaq 0x4737(%rip), %rcx      # 0x137df
movl $0x2, %r8d
xorl %esi, %esi
callq 0x22b0
movq %rbx, %rdi
callq 0xc41a
leaq 0x5050(%rbx), %rdi
leaq 0x4201(%rip), %rsi      # 0x132cc
callq 0x2080
incl 0x71f4(%rbx)
movq %rbx, %rdi
callq 0xf0ec
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xf136
// File: /workspace/github_cpp_makefile_star2_O1/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::ExpListB()
void Parse::ExpListB()//expression list for multiple iterations
{where="ELB";check();
   if(LHS==",")
   {
      tempSizeWrite++;
      match();
      Exp();
      ExpListB();
   }else
   {
      
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x5098(%rdi), %r14
leaq 0x5050(%rdi), %r12
leaq 0x4214(%rip), %r13      # 0x13370
leaq 0x5070(%rdi), %r15
movq 0x50a0(%rbx), %rdx
movl $0x3, %r8d
movq %r14, %rdi
xorl %esi, %esi
leaq 0x4666(%rip), %rcx      # 0x137e2
callq 0x22b0
movq %rbx, %rdi
callq 0xc41a
movq %r12, %rdi
movq %r13, %rsi
callq 0x2080
testl %eax, %eax
jne 0xf1cf
incl 0x71f4(%rbx)
movq %r15, %rdi
movq %r12, %rsi
callq 0x2100
movslq 0x2028(%rbx), %rsi
shlq $0x5, %rsi
addq %rbx, %rsi
movq %r12, %rdi
callq 0x2100
incl 0x2028(%rbx)
movq %rbx, %rdi
callq 0xf0ec
jmp 0xf163
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::GarCmd(int&, int)
void Parse::GarCmd(int &l1, int l2)//guarded command
{where="GC";check();

   gen.emit2("DEFADDR", l1);
      Exp();
   l1 = newLabel();
   if(LHS=="->")
   {
      gen.emit2("ARROW", l1);
      match();
      StatPtr();
      gen.emit2("BAR", l2);
   }else
      errorReport();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %edx, -0x2c(%rbp)
movq %rsi, %r12
movq %rdi, %r14
addq $0x5098, %rdi           # imm = 0x5098
movq 0x50a0(%r14), %rdx
leaq 0x45c2(%rip), %rcx      # 0x1382f
movl $0x2, %r8d
xorl %esi, %esi
callq 0x22b0
movq %r14, %rdi
callq 0xc41a
leaq 0x50c0(%r14), %r15
leaq -0x80(%rbp), %rbx
movq %rbx, -0x10(%rbx)
leaq 0x441b(%rip), %rsi      # 0x136b3
leaq 0x441b(%rip), %rdx      # 0x136ba
leaq -0x90(%rbp), %r13
movq %r13, %rdi
callq 0x42dc
movl (%r12), %edx
movq %r15, %rdi
movq %r13, %rsi
callq 0xab04
movq -0x90(%rbp), %rdi
cmpq %rbx, %rdi
je 0xf2ce
callq 0x21b0
movq %r14, %rdi
callq 0xf0ec
movl 0x71b0(%r14), %eax
incl %eax
movl %eax, 0x71b0(%r14)
movl %eax, (%r12)
leaq 0x5050(%r14), %r13
leaq 0x4088(%rip), %rsi      # 0x13380
movq %r13, %rdi
callq 0x2080
testl %eax, %eax
je 0xf311
movq %r14, %rdi
callq 0xc1be
jmp 0xf3c7
leaq -0x40(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0x4512(%rip), %rsi      # 0x13832
leaq 0x4510(%rip), %rdx      # 0x13837
leaq -0x50(%rbp), %rbx
movq %rbx, %rdi
callq 0x42dc
movl (%r12), %edx
movq %r15, %rdi
movq %rbx, %rsi
callq 0xab04
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0xf354
callq 0x21b0
leaq 0x5070(%r14), %rdi
movq %r13, %rsi
callq 0x2100
movslq 0x2028(%r14), %rsi
shlq $0x5, %rsi
addq %r14, %rsi
movq %r13, %rdi
callq 0x2100
incl 0x2028(%r14)
movq %r14, %rdi
callq 0xd246
leaq -0x60(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x44a0(%rip), %rsi      # 0x13838
leaq 0x449c(%rip), %rdx      # 0x1383b
leaq -0x70(%rbp), %rbx
movq %rbx, %rdi
callq 0x42dc
movq %r15, %rdi
movq %rbx, %rsi
movl -0x2c(%rbp), %edx
callq 0xab04
movq -0x70(%rbp), %rdi
cmpq %r12, %rdi
je 0xf3c7
callq 0x21b0
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq -0x70(%rbp), %rdi
cmpq %r12, %rdi
jne 0xf405
jmp 0xf40a
movq %rax, %r14
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
jne 0xf405
jmp 0xf40a
movq %rax, %r14
movq -0x90(%rbp), %rdi
cmpq %rbx, %rdi
je 0xf40a
callq 0x21b0
movq %r14, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O1/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::GarCmdListB(int&, int)
void Parse::GarCmdListB(int &l1, int l2)//guarded command list for multiple iterations
{where="GCLB";check();
   if(LHS=="["||LHS=="[]")
   {
      match();
      if(LHS=="]"||NS=="[]")
      {
	 match();
	 GarCmd(l1, l2);
	 GarCmdListB(l1, l2);
      }else
	 errorReport();
   }else
   {
      
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, -0x2c(%rbp)
movq %rsi, %r15
movq %rdi, %r14
leaq 0x5098(%rdi), %r12
leaq 0x5050(%rdi), %r13
leaq 0x5070(%rdi), %rbx
movq 0x50a0(%r14), %rdx
movl $0x4, %r8d
movq %r12, %rdi
xorl %esi, %esi
leaq 0x43d3(%rip), %rcx      # 0x1382a
callq 0x22b0
movq %r14, %rdi
callq 0xc41a
movq %r13, %rdi
leaq 0x41fb(%rip), %rsi      # 0x13669
callq 0x2080
testl %eax, %eax
je 0xf48e
movq %r13, %rdi
leaq 0x3ef9(%rip), %rsi      # 0x1337a
callq 0x2080
testl %eax, %eax
jne 0xf517
movq %rbx, %rdi
movq %r13, %rsi
callq 0x2100
movslq 0x2028(%r14), %rsi
shlq $0x5, %rsi
addq %r14, %rsi
movq %r13, %rdi
callq 0x2100
incl 0x2028(%r14)
movq %r13, %rdi
leaq 0x3ebb(%rip), %rsi      # 0x1337b
callq 0x2080
testl %eax, %eax
je 0xf4dc
movq %rbx, %rdi
leaq 0x3ea7(%rip), %rsi      # 0x1337a
callq 0x2080
testl %eax, %eax
jne 0xf526
movq %rbx, %rdi
movq %r13, %rsi
callq 0x2100
movslq 0x2028(%r14), %rsi
shlq $0x5, %rsi
addq %r14, %rsi
movq %r13, %rdi
callq 0x2100
incl 0x2028(%r14)
movq %r14, %rdi
movq %r15, %rsi
movl -0x2c(%rbp), %edx
callq 0xf23e
jmp 0xf43e
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xc1be
// File: /workspace/github_cpp_makefile_star2_O1/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::ExpB()
void Parse::ExpB()//expression for multiple iterations
{where="EB";check();
   if(LHS=="|"||LHS=="&")
   {
      PrimOp();
      PrimExp();
      ExpB();
   }else
   {
      
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x5098(%rdi), %r14
leaq 0x42a5(%rip), %r15      # 0x1384a
leaq 0x5050(%rdi), %r12
leaq 0x3dc1(%rip), %r13      # 0x13374
movq 0x50a0(%rbx), %rdx
movl $0x2, %r8d
movq %r14, %rdi
xorl %esi, %esi
movq %r15, %rcx
callq 0x22b0
movq %rbx, %rdi
callq 0xc41a
movq %r12, %rdi
movq %r13, %rsi
callq 0x2080
testl %eax, %eax
je 0xf5f7
movq %r12, %rdi
leaq 0x3d84(%rip), %rsi      # 0x13372
callq 0x2080
testl %eax, %eax
jne 0xf609
movq %rbx, %rdi
callq 0xf618
movq %rbx, %rdi
callq 0xf53c
jmp 0xf5b3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::PrimOp()
void Parse::PrimOp()//primary operations
{where="PO";check();
   if(LHS=="&")
   {
      gen.emit1("AND");
      match();
   }else if(LHS=="|")
   {
      gen.emit1("OR");
      match();
   }else
      errorReport();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x40, %rsp
movq %rdi, %rbx
addq $0x5098, %rdi           # imm = 0x5098
movq 0x50a0(%rbx), %rdx
leaq 0x41fd(%rip), %rcx      # 0x1383c
movl $0x2, %r8d
xorl %esi, %esi
callq 0x22b0
movq %rbx, %rdi
callq 0xc41a
leaq 0x5050(%rbx), %r14
leaq 0x3d10(%rip), %rsi      # 0x13372
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xf695
leaq 0x3cff(%rip), %rsi      # 0x13374
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xf6cd
movq %rbx, %rdi
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xc1be
leaq -0x50(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x419a(%rip), %rsi      # 0x1383f
leaq 0x4196(%rip), %rdx      # 0x13842
leaq -0x60(%rbp), %r15
movq %r15, %rdi
callq 0x42dc
leaq 0x50c0(%rbx), %rdi
movq %r15, %rsi
callq 0xaa88
movq -0x60(%rbp), %rdi
jmp 0xf703
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x4166(%rip), %rsi      # 0x13843
leaq 0x4161(%rip), %rdx      # 0x13845
leaq -0x40(%rbp), %r15
movq %r15, %rdi
callq 0x42dc
leaq 0x50c0(%rbx), %rdi
movq %r15, %rsi
callq 0xaa88
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0xf70d
callq 0x21b0
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)
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
jmp 0xf755
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0xf75f
callq 0x21b0
movq %rbx, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O1/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::SimpExp()
void Parse::SimpExp()//simple expression
{where="SE";check();
   Line();
   Term();
   SimpExpB();

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x5098, %rdi           # imm = 0x5098
movq 0x50a0(%rbx), %rdx
leaq 0x40dd(%rip), %rcx      # 0x13863
movl $0x2, %r8d
xorl %esi, %esi
callq 0x22b0
movq %rbx, %rdi
callq 0xc41a
movq %rbx, %rdi
callq 0xf9f0
movq %rbx, %rdi
callq 0xfa6e
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xfab8
nop
// File: /workspace/github_cpp_makefile_star2_O1/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::PrimExpB()
void Parse::PrimExpB()//primary expression for multiple iterations
{where="PEB";check();
   if(LHS=="<"||LHS=="="||LHS==">")
   {
      RelatOp();
      SimpExp();
   }else
   {
      
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
addq $0x5098, %rdi           # imm = 0x5098
movq 0x50a0(%rbx), %rdx
leaq 0x4070(%rip), %rcx      # 0x13849
movl $0x3, %r8d
xorl %esi, %esi
callq 0x22b0
movq %rbx, %rdi
callq 0xc41a
leaq 0x5050(%rbx), %r14
leaq 0x3b7c(%rip), %rsi      # 0x13378
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xf833
leaq 0x3b6f(%rip), %rsi      # 0x1337e
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xf833
leaq 0x3b5f(%rip), %rsi      # 0x13381
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xf833
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
callq 0xf848
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xf768
nop