LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/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 0x520b(%rip), %rcx      # 0x137d6
movl $0x2, %r8d
xorl %esi, %esi
callq 0x22b0
movq %rbx, %rdi
callq 0xc3e8
leaq 0x5050(%rbx), %r14
leaq 0x4a71(%rip), %rsi      # 0x1305f
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
jne 0xe680
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 0xf0e2
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x5199(%rip), %rsi      # 0x137d9
leaq 0x5197(%rip), %rdx      # 0x137de
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x42ea
leaq 0x50c0(%rbx), %rdi
movl 0x71f4(%rbx), %edx
movq %r14, %rsi
callq 0xaae4
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0xe676
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 0xe69c
callq 0x21b0
movq %rbx, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O3/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 0x511d(%rip), %rcx      # 0x137e6
movl $0x2, %r8d
xorl %esi, %esi
callq 0x22b0
movq %rbx, %rdi
callq 0xc3e8
movq %rbx, %rdi
callq 0xed88
leaq 0x5050(%rbx), %r14
leaq 0x4c89(%rip), %rsi      # 0x1337d
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xe70a
movq %rbx, %rdi
callq 0xc18c
jmp 0xe73d
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 0xf0e2
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x509d(%rip), %rsi      # 0x137e9
leaq 0x509c(%rip), %rdx      # 0x137ef
leaq -0x38(%rbp), %r14
movq %r14, %rdi
callq 0x42ea
leaq 0x50c0(%rbx), %rdi
movl 0x71f8(%rbx), %edx
movq %r14, %rsi
callq 0xaae4
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0xe782
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 0xe7a8
callq 0x21b0
movq %rbx, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5019(%rip), %rcx      # 0x137f0
movl $0x2, %r8d
xorl %esi, %esi
callq 0x22b0
movq %rbx, %rdi
callq 0xc3e8
leaq 0x5050(%rbx), %r14
leaq 0x4b58(%rip), %rsi      # 0x13352
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
jne 0xe914
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 0xe20c
leaq 0x4c38(%rbx), %r14
movl 0x4ddc(%rbx), %esi
movq %r14, %rdi
callq 0x104e8
testb %al, %al
jne 0xe892
leaq -0x50(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x4f8d(%rip), %rsi      # 0x137f3
leaq 0x4fa7(%rip), %rdx      # 0x13814
leaq -0x60(%rbp), %r15
movq %r15, %rdi
callq 0x42ea
movq %rbx, %rdi
movq %r15, %rsi
callq 0xc50a
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0xe892
callq 0x21b0
movl 0x4ddc(%rbx), %edx
leaq -0x7c(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0x10a12
movups (%r15), %xmm0
movups 0xc(%r15), %xmm1
movups %xmm1, 0x4e1c(%rbx)
movups %xmm0, 0x4e10(%rbx)
leaq -0x30(%rbp), %r15
movq %r15, -0x10(%r15)
leaq 0x4f48(%rip), %rsi      # 0x13815
leaq 0x4f45(%rip), %rdx      # 0x13819
leaq -0x40(%rbp), %rdi
callq 0x42ea
movl 0x4ddc(%rbx), %esi
movq %r14, %rdi
callq 0x109d0
movl 0x4e28(%rbx), %ecx
addq $0x50c0, %rbx           # imm = 0x50C0
leaq -0x40(%rbp), %rsi
movq %rbx, %rdi
movl %eax, %edx
callq 0xab98
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0xe914
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 0xe93b
jmp 0xe940
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r15, %rdi
je 0xe940
callq 0x21b0
movq %rbx, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4ea6(%rip), %rcx      # 0x1381a
movl $0x2, %r8d
xorl %esi, %esi
callq 0x22b0
movq %rbx, %rdi
callq 0xc3e8
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 0xf26e
leaq 0x50c0(%rbx), %r15
leaq -0x58(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0x4cb2(%rip), %rsi      # 0x136b3
leaq 0x4cb2(%rip), %rdx      # 0x136ba
leaq -0x68(%rbp), %r13
movq %r13, %rdi
callq 0x42ea
movq %r15, -0x30(%rbp)
movq %r15, %rdi
movq %r13, %rsi
movl %r12d, %edx
callq 0xaae4
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0xea38
callq 0x21b0
leaq 0x491e(%rip), %rsi      # 0x1335d
movq -0x40(%rbp), %r15
movq %r15, %rdi
callq 0x2080
testl %eax, %eax
je 0xea5c
movq %rbx, %rdi
callq 0xc18c
jmp 0xeb20
leaq -0x98(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x4daf(%rip), %rsi      # 0x1381d
leaq 0x4daa(%rip), %rdx      # 0x1381f
leaq -0xa8(%rbp), %r12
movq %r12, %rdi
callq 0x42ea
movslq 0x2028(%rbx), %rax
leaq (%rax,%rax,2), %rax
movl 0x2030(%rbx,%rax,4), %edx
movq -0x30(%rbp), %rdi
movq %r12, %rsi
callq 0xaae4
movq -0xa8(%rbp), %rdi
cmpq %r13, %rdi
je 0xeab3
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 0x4bc9(%rip), %rsi      # 0x136b3
leaq 0x4bc9(%rip), %rdx      # 0x136ba
leaq -0x88(%rbp), %rbx
movq %rbx, %rdi
callq 0x42ea
movq -0x30(%rbp), %rdi
movq %rbx, %rsi
movl %r14d, %edx
callq 0xaae4
movq -0x88(%rbp), %rdi
cmpq %r15, %rdi
je 0xeb20
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 0xeb64
jmp 0xeb69
movq %rax, %rbx
movq -0xa8(%rbp), %rdi
cmpq %r13, %rdi
jne 0xeb64
jmp 0xeb69
movq %rax, %rbx
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0xeb69
callq 0x21b0
movq %rbx, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O3/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::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 0x4c85(%rip), %rcx      # 0x13820
movl $0x2, %r8d
xorl %esi, %esi
callq 0x22b0
movq %rbx, %rdi
callq 0xc3e8
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 0x4a9b(%rip), %rsi      # 0x136b3
leaq 0x4a9b(%rip), %rdx      # 0x136ba
leaq -0x60(%rbp), %r13
movq %r13, %rdi
callq 0x42ea
movq %r12, -0x38(%rbp)
movq %r12, %rdi
movq %r13, %rsi
movl %r14d, %edx
callq 0xaae4
movq -0x60(%rbp), %rdi
leaq -0x50(%rbp), %rax
cmpq %rax, %rdi
je 0xec4f
callq 0x21b0
leaq -0x30(%rbp), %rsi
movq %rbx, %rdi
movl %r14d, %edx
callq 0xf26e
leaq 0x46fb(%rip), %rsi      # 0x13360
movq %r15, %rdi
callq 0x2080
testl %eax, %eax
je 0xec7e
movq %rbx, %rdi
callq 0xc18c
jmp 0xed3c
leaq -0x90(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x4b93(%rip), %rsi      # 0x13823
leaq 0x4b8e(%rip), %rdx      # 0x13825
leaq -0xa0(%rbp), %r14
movq %r14, %rdi
callq 0x42ea
movslq 0x2028(%rbx), %rax
leaq (%rax,%rax,2), %rax
movl 0x2030(%rbx,%rax,4), %edx
movq -0x38(%rbp), %rdi
movq %r14, %rsi
callq 0xaae4
movq -0xa0(%rbp), %rdi
cmpq %r13, %rdi
je 0xecd5
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 0x49a7(%rip), %rsi      # 0x136b3
leaq 0x49a7(%rip), %rdx      # 0x136ba
leaq -0x80(%rbp), %rbx
movq %rbx, %rdi
callq 0x42ea
movq -0x38(%rbp), %rdi
movq %rbx, %rsi
movl -0x2c(%rbp), %edx
callq 0xaae4
movq -0x80(%rbp), %rdi
cmpq %r14, %rdi
je 0xed3c
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 0xed7a
jmp 0xed7f
movq %rax, %rbx
movq -0xa0(%rbp), %rdi
cmpq %r13, %rdi
jne 0xed7a
jmp 0xed7f
movq %rax, %rbx
movq -0x60(%rbp), %rdi
leaq -0x50(%rbp), %rax
cmpq %rax, %rdi
je 0xed7f
callq 0x21b0
movq %rbx, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O3/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::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 0x4a27(%rip), %rcx      # 0x137cd
movl $0x3, %r8d
xorl %esi, %esi
callq 0x22b0
movq %rbx, %rdi
callq 0xc3e8
leaq 0x5050(%rbx), %rdi
leaq 0x4436(%rip), %rsi      # 0x131ff
callq 0x2080
testl %eax, %eax
je 0xede0
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xc18c
incl 0x71f0(%rbx)
incl 0x71f8(%rbx)
movq %rbx, %rdi
callq 0xee02
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xeffc
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4a7d(%rip), %rcx      # 0x138a9
movl $0x2, %r8d
xorl %esi, %esi
callq 0x22b0
movq %rbx, %rdi
callq 0xc3e8
leaq 0x5050(%rbx), %rdi
leaq 0x43b0(%rip), %rsi      # 0x131ff
callq 0x2080
testl %eax, %eax
je 0xee6f
movq %rbx, %rdi
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xc18c
movq %rbx, %rdi
callq 0xe05c
leaq 0x4c38(%rbx), %r15
movl 0x4ddc(%rbx), %edx
leaq -0x9c(%rbp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0x10a12
movups (%r14), %xmm0
movups 0xc(%r14), %xmm1
movups %xmm1, 0x4e1c(%rbx)
movups %xmm0, 0x4e10(%rbx)
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x49ef(%rip), %rsi      # 0x138ac
leaq 0x49f0(%rip), %rdx      # 0x138b4
leaq -0x40(%rbp), %rdi
callq 0x42ea
movl 0x4ddc(%rbx), %esi
movq %r15, %rdi
callq 0x109d0
leaq 0x50c0(%rbx), %r14
movl 0x4e24(%rbx), %ecx
leaq -0x40(%rbp), %rsi
movq %r14, %rdi
movl %eax, %edx
callq 0xab98
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0xef04
callq 0x21b0
movl 0x4ddc(%rbx), %esi
movq %r15, %rdi
callq 0x104e8
testb %al, %al
jne 0xef52
leaq -0x70(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x498f(%rip), %rsi      # 0x138b5
leaq 0x49aa(%rip), %rdx      # 0x138d7
leaq -0x80(%rbp), %r15
movq %r15, %rdi
callq 0x42ea
movq %rbx, %rdi
movq %r15, %rsi
callq 0xc50a
movq -0x80(%rbp), %rdi
cmpq %r12, %rdi
je 0xef52
callq 0x21b0
movq %rbx, %rdi
callq 0x101c6
cmpl $0x1, 0x71b4(%rbx)
jne 0xefc1
leaq -0x50(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x4965(%rip), %rsi      # 0x138d8
leaq 0x4963(%rip), %rdx      # 0x138dd
leaq -0x60(%rbp), %r15
movq %r15, %rdi
callq 0x42ea
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 0xab98
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0xefb7
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 0xefea
movq %rax, %rbx
movq -0x80(%rbp), %rdi
jmp 0xefea
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0xeff4
callq 0x21b0
movq %rbx, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O3/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
movq 0x50a0(%rdi), %rdx
leaq 0x47af(%rip), %rcx      # 0x137d1
movl $0x4, %r8d
movq %r14, %rdi
xorl %esi, %esi
callq 0x22b0
movq %rbx, %rdi
callq 0xc3e8
leaq 0x5050(%rbx), %r15
leaq 0x4328(%rip), %rsi      # 0x13370
movq %r15, %rdi
callq 0x2080
testl %eax, %eax
jne 0xf0d2
leaq 0x5070(%rbx), %r12
leaq 0x430e(%rip), %r13      # 0x13370
incl 0x71f0(%rbx)
incl 0x71f8(%rbx)
movq %r12, %rdi
movq %r15, %rsi
callq 0x2100
movslq 0x2028(%rbx), %rsi
shlq $0x5, %rsi
addq %rbx, %rsi
movq %r15, %rdi
callq 0x2100
incl 0x2028(%rbx)
movq %rbx, %rdi
callq 0xee02
movq 0x50a0(%rbx), %rdx
movl $0x4, %r8d
movq %r14, %rdi
xorl %esi, %esi
leaq 0x471b(%rip), %rcx      # 0x137d1
callq 0x22b0
movq %rbx, %rdi
callq 0xc3e8
movq %r15, %rdi
movq %r13, %rsi
callq 0x2080
testl %eax, %eax
je 0xf062
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::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 0x46df(%rip), %rcx      # 0x137df
movl $0x2, %r8d
xorl %esi, %esi
callq 0x22b0
movq %rbx, %rdi
callq 0xc3e8
leaq 0x5050(%rbx), %rdi
leaq 0x41a9(%rip), %rsi      # 0x132cc
callq 0x2080
incl 0x71f4(%rbx)
movq %rbx, %rdi
callq 0xf144
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xf18e
// File: /workspace/github_cpp_makefile_star2_O3/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
movq 0x50a0(%rdi), %rdx
leaq 0x462e(%rip), %rcx      # 0x137e2
movl $0x3, %r8d
movq %r14, %rdi
xorl %esi, %esi
callq 0x22b0
movq %rbx, %rdi
callq 0xc3e8
leaq 0x5050(%rbx), %r15
leaq 0x4196(%rip), %rsi      # 0x13370
movq %r15, %rdi
callq 0x2080
testl %eax, %eax
jne 0xf25e
leaq 0x5070(%rbx), %r12
leaq 0x417c(%rip), %r13      # 0x13370
incl 0x71f4(%rbx)
movq %r12, %rdi
movq %r15, %rsi
callq 0x2100
movslq 0x2028(%rbx), %rsi
shlq $0x5, %rsi
addq %rbx, %rsi
movq %r15, %rdi
callq 0x2100
incl 0x2028(%rbx)
movq %rbx, %rdi
callq 0xf144
movq 0x50a0(%rbx), %rdx
movl $0x3, %r8d
movq %r14, %rdi
xorl %esi, %esi
leaq 0x45a0(%rip), %rcx      # 0x137e2
callq 0x22b0
movq %rbx, %rdi
callq 0xc3e8
movq %r15, %rdi
movq %r13, %rsi
callq 0x2080
testl %eax, %eax
je 0xf1f4
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::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 0x4532(%rip), %rcx      # 0x1382f
movl $0x2, %r8d
xorl %esi, %esi
callq 0x22b0
movq %r14, %rdi
callq 0xc3e8
leaq 0x50c0(%r14), %r15
leaq -0x80(%rbp), %rbx
movq %rbx, -0x10(%rbx)
leaq 0x438b(%rip), %rsi      # 0x136b3
leaq 0x438b(%rip), %rdx      # 0x136ba
leaq -0x90(%rbp), %r13
movq %r13, %rdi
callq 0x42ea
movl (%r12), %edx
movq %r15, %rdi
movq %r13, %rsi
callq 0xaae4
movq -0x90(%rbp), %rdi
cmpq %rbx, %rdi
je 0xf35e
callq 0x21b0
movq %r14, %rdi
callq 0xf144
movl 0x71b0(%r14), %eax
incl %eax
movl %eax, 0x71b0(%r14)
movl %eax, (%r12)
leaq 0x5050(%r14), %r13
leaq 0x3ff8(%rip), %rsi      # 0x13380
movq %r13, %rdi
callq 0x2080
testl %eax, %eax
je 0xf3a1
movq %r14, %rdi
callq 0xc18c
jmp 0xf457
leaq -0x40(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0x4482(%rip), %rsi      # 0x13832
leaq 0x4480(%rip), %rdx      # 0x13837
leaq -0x50(%rbp), %rbx
movq %rbx, %rdi
callq 0x42ea
movl (%r12), %edx
movq %r15, %rdi
movq %rbx, %rsi
callq 0xaae4
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
je 0xf3e4
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 0xd1e8
leaq -0x60(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x4410(%rip), %rsi      # 0x13838
leaq 0x440c(%rip), %rdx      # 0x1383b
leaq -0x70(%rbp), %rbx
movq %rbx, %rdi
callq 0x42ea
movq %r15, %rdi
movq %rbx, %rsi
movl -0x2c(%rbp), %edx
callq 0xaae4
movq -0x70(%rbp), %rdi
cmpq %r12, %rdi
je 0xf457
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 0xf495
jmp 0xf49a
movq %rax, %r14
movq -0x50(%rbp), %rdi
leaq -0x40(%rbp), %rax
cmpq %rax, %rdi
jne 0xf495
jmp 0xf49a
movq %rax, %r14
movq -0x90(%rbp), %rdi
cmpq %rbx, %rdi
je 0xf49a
callq 0x21b0
movq %r14, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4343(%rip), %rcx      # 0x1382a
callq 0x22b0
movq %r14, %rdi
callq 0xc3e8
movq %r13, %rdi
leaq 0x416b(%rip), %rsi      # 0x13669
callq 0x2080
testl %eax, %eax
je 0xf51e
movq %r13, %rdi
leaq 0x3e69(%rip), %rsi      # 0x1337a
callq 0x2080
testl %eax, %eax
jne 0xf5a7
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 0x3e2b(%rip), %rsi      # 0x1337b
callq 0x2080
testl %eax, %eax
je 0xf56c
movq %rbx, %rdi
leaq 0x3e17(%rip), %rsi      # 0x1337a
callq 0x2080
testl %eax, %eax
jne 0xf5b6
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 0xf2ce
jmp 0xf4ce
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 0xc18c
// File: /workspace/github_cpp_makefile_star2_O3/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 0x5050(%rdi), %r15
leaq 0x420e(%rip), %r12      # 0x1384a
leaq 0x3d31(%rip), %r13      # 0x13374
movq 0x50a0(%rbx), %rdx
movl $0x2, %r8d
movq %r14, %rdi
xorl %esi, %esi
movq %r12, %rcx
callq 0x22b0
movq %rbx, %rdi
callq 0xc3e8
movq %r15, %rdi
movq %r13, %rsi
callq 0x2080
testl %eax, %eax
je 0xf687
movq %r15, %rdi
leaq 0x3cf4(%rip), %rsi      # 0x13372
callq 0x2080
testl %eax, %eax
jne 0xf699
movq %rbx, %rdi
callq 0xf6a8
movq %rbx, %rdi
callq 0xf5cc
jmp 0xf643
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::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 0x416d(%rip), %rcx      # 0x1383c
movl $0x2, %r8d
xorl %esi, %esi
callq 0x22b0
movq %rbx, %rdi
callq 0xc3e8
leaq 0x5050(%rbx), %r14
leaq 0x3c80(%rip), %rsi      # 0x13372
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xf725
leaq 0x3c6f(%rip), %rsi      # 0x13374
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xf75d
movq %rbx, %rdi
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xc18c
leaq -0x50(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x410a(%rip), %rsi      # 0x1383f
leaq 0x4106(%rip), %rdx      # 0x13842
leaq -0x60(%rbp), %r15
movq %r15, %rdi
callq 0x42ea
leaq 0x50c0(%rbx), %rdi
movq %r15, %rsi
callq 0xaa68
movq -0x60(%rbp), %rdi
jmp 0xf793
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x40d6(%rip), %rsi      # 0x13843
leaq 0x40d1(%rip), %rdx      # 0x13845
leaq -0x40(%rbp), %r15
movq %r15, %rdi
callq 0x42ea
leaq 0x50c0(%rbx), %rdi
movq %r15, %rsi
callq 0xaa68
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0xf79d
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 0xf7e5
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0xf7ef
callq 0x21b0
movq %rbx, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O3/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::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 0x404d(%rip), %rcx      # 0x13863
movl $0x2, %r8d
xorl %esi, %esi
callq 0x22b0
movq %rbx, %rdi
callq 0xc3e8
movq %rbx, %rdi
callq 0xfa80
movq %rbx, %rdi
callq 0xfafe
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xfb48
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x3fe0(%rip), %rcx      # 0x13849
movl $0x3, %r8d
xorl %esi, %esi
callq 0x22b0
movq %rbx, %rdi
callq 0xc3e8
leaq 0x5050(%rbx), %r14
leaq 0x3aec(%rip), %rsi      # 0x13378
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xf8c3
leaq 0x3adf(%rip), %rsi      # 0x1337e
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xf8c3
leaq 0x3acf(%rip), %rsi      # 0x13381
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xf8c3
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
callq 0xf8d8
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xf7f8
nop
// File: /workspace/github_cpp_makefile_star2_O3/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::RelatOp()
void Parse::RelatOp()//relational operator
{where="RO";check();
   if(LHS=="<")
   {
      gen.emit1("LESS");
      match();
   }else if(LHS=="=")
   {
      gen.emit1("EQUAL");
      match();
   }else if(LHS==">")
   {
      gen.emit1("GREATER");
      match();
   }else
      errorReport();
}

// 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 0x3f4e(%rip), %rcx      # 0x1384d
movl $0x2, %r8d
xorl %esi, %esi
callq 0x22b0
movq %rbx, %rdi
callq 0xc3e8
leaq 0x5050(%rbx), %r14
leaq 0x3a56(%rip), %rsi      # 0x13378
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xf96c
leaq 0x3a49(%rip), %rsi      # 0x1337e
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xf9a4
leaq 0x3a39(%rip), %rsi      # 0x13381
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xf9dc
movq %rbx, %rdi
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xc18c
leaq -0x70(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x3ed4(%rip), %rsi      # 0x13850
leaq 0x3ed1(%rip), %rdx      # 0x13854
leaq -0x80(%rbp), %r15
movq %r15, %rdi
callq 0x42ea
leaq 0x50c0(%rbx), %rdi
movq %r15, %rsi
callq 0xaa68
movq -0x80(%rbp), %rdi
jmp 0xfa12
leaq -0x50(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x3ea1(%rip), %rsi      # 0x13855
leaq 0x3e9f(%rip), %rdx      # 0x1385a
leaq -0x60(%rbp), %r15
movq %r15, %rdi
callq 0x42ea
leaq 0x50c0(%rbx), %rdi
movq %r15, %rsi
callq 0xaa68
movq -0x60(%rbp), %rdi
jmp 0xfa12
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x3e6f(%rip), %rsi      # 0x1385b
leaq 0x3e6f(%rip), %rdx      # 0x13862
leaq -0x40(%rbp), %r15
movq %r15, %rdi
callq 0x42ea
leaq 0x50c0(%rbx), %rdi
movq %r15, %rsi
callq 0xaa68
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0xfa1c
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 $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
jmp 0xfa6d
movq %rax, %rbx
movq -0x60(%rbp), %rdi
jmp 0xfa6d
movq %rax, %rbx
movq -0x80(%rbp), %rdi
cmpq %r12, %rdi
je 0xfa77
callq 0x21b0
movq %rbx, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O3/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::Line()
void Parse::Line()
{where="L";check();
   if(LHS=="-")
   {
      
      match();
   }else
   {

   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
addq $0x5098, %rdi           # imm = 0x5098
movq 0x50a0(%rbx), %rdx
leaq 0x3dba(%rip), %rcx      # 0x13859
movl $0x1, %r8d
xorl %esi, %esi
callq 0x22b0
movq %rbx, %rdi
callq 0xc3e8
leaq 0x5050(%rbx), %r14
leaq 0x380a(%rip), %rsi      # 0x132cc
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
jne 0xfaf9
leaq 0x5070(%rbx), %rdi
movq %r14, %rsi
callq 0x2100
movslq 0x2028(%rbx), %rsi
shlq $0x5, %rsi
addq %rbx, %rsi
movq %r14, %rdi
callq 0x2100
incl 0x2028(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::SimpExpB()
void Parse::SimpExpB()//simple expression for multiple iterations
{where="SEB";check();
   if(LHS=="-"||LHS=="+")
   {
      AddOp();
      Term();
      SimpExpB();
   }else
   {

   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x5098(%rdi), %r14
leaq 0x5050(%rdi), %r15
leaq 0x3cf8(%rip), %r12      # 0x13866
leaq 0x3757(%rip), %r13      # 0x132cc
movq 0x50a0(%rbx), %rdx
movl $0x3, %r8d
movq %r14, %rdi
xorl %esi, %esi
movq %r12, %rcx
callq 0x22b0
movq %rbx, %rdi
callq 0xc3e8
movq %r15, %rdi
movq %r13, %rsi
callq 0x2080
testl %eax, %eax
je 0xfbb9
movq %r15, %rdi
leaq 0x371a(%rip), %rsi      # 0x132ca
callq 0x2080
testl %eax, %eax
jne 0xfbcb
movq %rbx, %rdi
callq 0xfbda
movq %rbx, %rdi
callq 0xfafe
jmp 0xfb75
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::AddOp()
void Parse::AddOp()//Add/subtract operator
{where="AO";check();
   if(LHS=="+")
   {
      gen.emit1("ADD");
      match();
   }else if(LHS=="-")
   {
      gen.emit1("SUBTRACT");
      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 0x3c69(%rip), %rcx      # 0x1386a
movl $0x2, %r8d
xorl %esi, %esi
callq 0x22b0
movq %rbx, %rdi
callq 0xc3e8
leaq 0x5050(%rbx), %r14
leaq 0x36a6(%rip), %rsi      # 0x132ca
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xfc57
leaq 0x3695(%rip), %rsi      # 0x132cc
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xfc8f
movq %rbx, %rdi
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xc18c
leaq -0x50(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x3c06(%rip), %rsi      # 0x1386d
leaq 0x3c02(%rip), %rdx      # 0x13870
leaq -0x60(%rbp), %r15
movq %r15, %rdi
callq 0x42ea
leaq 0x50c0(%rbx), %rdi
movq %r15, %rsi
callq 0xaa68
movq -0x60(%rbp), %rdi
jmp 0xfcc5
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x3bd2(%rip), %rsi      # 0x13871
leaq 0x3bd3(%rip), %rdx      # 0x13879
leaq -0x40(%rbp), %r15
movq %r15, %rdi
callq 0x42ea
leaq 0x50c0(%rbx), %rdi
movq %r15, %rsi
callq 0xaa68
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0xfccf
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 0xfd17
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0xfd21
callq 0x21b0
movq %rbx, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O3/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::TermB()
void Parse::TermB()//term for multiple iterations
{where="TB";check();
   if(LHS=="*"||LHS=="%"||LHS=="/")
   {
      MultOp();
      Factor();
      TermB();
   }else
   {

   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x5098(%rdi), %r14
leaq 0x5050(%rdi), %r15
leaq 0x38dc(%rip), %r12      # 0x1387a
leaq 0x3329(%rip), %r13      # 0x132ce
movq 0x50a0(%rbx), %rdx
movl $0x2, %r8d
movq %r14, %rdi
xorl %esi, %esi
movq %r12, %rcx
callq 0x22b0
movq %rbx, %rdi
callq 0xc3e8
movq %r15, %rdi
movq %r13, %rsi
callq 0x2080
testl %eax, %eax
je 0xfffc
movq %r15, %rdi
leaq 0x32e6(%rip), %rsi      # 0x132c6
callq 0x2080
testl %eax, %eax
je 0xfffc
movq %r15, %rdi
leaq 0x32d1(%rip), %rsi      # 0x132c4
callq 0x2080
testl %eax, %eax
jne 0x1000e
movq %rbx, %rdi
callq 0x1001e
movq %rbx, %rdi
callq 0xfd2a
jmp 0xffa5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::MultOp()
void Parse::MultOp()//multiplying, div, and mod operator
{where="MO";check();
   if(LHS=="*")
   {
      gen.emit1("TIMES");
      match();
   }else if(LHS=="%")
   {
      gen.emit1("MODULO");
      match();
   }else if(LHS=="/")
   {
      gen.emit1("DIVIDE");
      match();
   }else
      errorReport();
}

// 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 0x3838(%rip), %rcx      # 0x1387d
movl $0x2, %r8d
xorl %esi, %esi
callq 0x22b0
movq %rbx, %rdi
callq 0xc3e8
leaq 0x5050(%rbx), %r14
leaq 0x3266(%rip), %rsi      # 0x132ce
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0x100b2
leaq 0x324b(%rip), %rsi      # 0x132c6
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0x100ea
leaq 0x3236(%rip), %rsi      # 0x132c4
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0x10122
movq %rbx, %rdi
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xc18c
leaq -0x70(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x37be(%rip), %rsi      # 0x13880
leaq 0x37bc(%rip), %rdx      # 0x13885
leaq -0x80(%rbp), %r15
movq %r15, %rdi
callq 0x42ea
leaq 0x50c0(%rbx), %rdi
movq %r15, %rsi
callq 0xaa68
movq -0x80(%rbp), %rdi
jmp 0x10158
leaq -0x50(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x378c(%rip), %rsi      # 0x13886
leaq 0x378b(%rip), %rdx      # 0x1388c
leaq -0x60(%rbp), %r15
movq %r15, %rdi
callq 0x42ea
leaq 0x50c0(%rbx), %rdi
movq %r15, %rsi
callq 0xaa68
movq -0x60(%rbp), %rdi
jmp 0x10158
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x375b(%rip), %rsi      # 0x1388d
leaq 0x375a(%rip), %rdx      # 0x13893
leaq -0x40(%rbp), %r15
movq %r15, %rdi
callq 0x42ea
leaq 0x50c0(%rbx), %rdi
movq %r15, %rsi
callq 0xaa68
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x10162
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 $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
jmp 0x101b3
movq %rax, %rbx
movq -0x60(%rbp), %rdi
jmp 0x101b3
movq %rax, %rbx
movq -0x80(%rbp), %rdi
cmpq %r12, %rdi
je 0x101bd
callq 0x21b0
movq %rbx, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O3/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::VarAcB()
void Parse::VarAcB()//variable access for mulitple iterations
{where="VAB";check();
   if(LHS=="[")
   {
      ary = 1;
      IndexSelect();
   }else
   {

   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x5098, %rdi           # imm = 0x5098
movq 0x50a0(%rbx), %rdx
leaq 0x36fa(%rip), %rcx      # 0x138de
movl $0x3, %r8d
xorl %esi, %esi
callq 0x22b0
movq %rbx, %rdi
callq 0xc3e8
leaq 0x5050(%rbx), %rdi
leaq 0x3462(%rip), %rsi      # 0x13669
callq 0x2080
testl %eax, %eax
je 0x10217
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl $0x1, 0x71b4(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x10230
nop
// File: /workspace/github_cpp_makefile_star2_O3/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::IndexSelect()
void Parse::IndexSelect()
{where="IS";check();
   if(LHS=="[")
   {
      match();
      
      Exp();
      if(LHS=="]")
      {
	 match();
      }
   }
}

// 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 0x35c8(%rip), %rcx      # 0x1381a
movl $0x2, %r8d
xorl %esi, %esi
callq 0x22b0
movq %rbx, %rdi
callq 0xc3e8
leaq 0x5050(%rbx), %r14
leaq 0x33f4(%rip), %rsi      # 0x13669
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
jne 0x102f1
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 0xf144
leaq 0x30bd(%rip), %rsi      # 0x1337b
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
jne 0x102f1
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)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::Num()
void Parse::Num()//number
{where="N";check();
   if(LHS=="num")
   {  //initialise val of number
      //asnIndexVal(vl);
      checkVal=ln[tokeNum][2];
      tpVl=checkVal;
      //cout<<endl<<checkVal<<"  "<<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 0x35ce(%rip), %rcx      # 0x138e9
movl $0x1, %r8d
xorl %esi, %esi
callq 0x22b0
movq %rbx, %rdi
callq 0xc3e8
leaq 0x5050(%rbx), %r14
leaq 0x2f82(%rip), %rsi      # 0x132c0
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0x10356
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xc18c
movslq 0x2028(%rbx), %rax
leaq (%rax,%rax,2), %rax
movl 0x2038(%rbx,%rax,4), %eax
movl %eax, 0x4de4(%rbx)
movl %eax, 0x7228(%rbx)
leaq 0x5070(%rbx), %rdi
movq %r14, %rsi
callq 0x2100
movslq 0x2028(%rbx), %rsi
shlq $0x5, %rsi
addq %rbx, %rsi
movq %r14, %rdi
callq 0x2100
incl 0x2028(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::BoolSym()
void Parse::BoolSym()//boolean symbol
{where="BS";check();
   if(LHS=="false")
   {  //calling to initialize val to 0 for the type
      checkVal = 0;
      varListVal[listDepth] = 0;
      tpVl=checkVal;
      //ctd
      match();
   }else if(LHS=="true")
   {  //calling to initialize val to 1 for the type
      checkVal = 1;
      varListVal[listDepth] = 1;
      tpVl=checkVal;
      //ctd
      match();
   }else
      errorReport();
}

// 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 0x351c(%rip), %rcx      # 0x138e2
xorl %r15d, %r15d
movl $0x2, %r8d
xorl %esi, %esi
callq 0x22b0
movq %rbx, %rdi
callq 0xc3e8
leaq 0x5050(%rbx), %r14
leaq 0x2f77(%rip), %rsi      # 0x13363
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0x1041d
leaq 0x2f6a(%rip), %rsi      # 0x13369
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0x10435
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xc18c
movl %r15d, 0x4de4(%rbx)
movslq 0x4d88(%rbx), %rax
movl %r15d, 0x4d60(%rbx,%rax,4)
jmp 0x1044e
movl $0x1, %eax
movl %eax, 0x4de4(%rbx)
movslq 0x4d88(%rbx), %rcx
movl %eax, 0x4d60(%rbx,%rcx,4)
movl 0x4de4(%rbx), %eax
movl %eax, 0x7228(%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)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/navrajsaini[P]PL_Compiler_design_project/BlockTable.cpp
// Function: BlockTable::search(int)
bool BlockTable::search(int index)
{
   int tempcomp;//temp variable for comparison done in if block
   for (int i = 0; i < blockLevel; i++)
   {
      /*for(int j = 0; j < table[i].size(); j++)*/
      for (auto it = table[i].begin(); it != table[i].end(); ++it)
      {
	 tempcomp = it -> idindex;
	 if (tempcomp == index)//the comparison that tempcomp is needed for
	 {
	    return true;
	 }
      }
   }

   for (auto it = table[blockLevel].begin(); it != table[blockLevel].end(); ++it)
   {
      if (it -> idindex == index)
	 return true;
   }
   return false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq 0xf8(%rdi), %rax
testq %rax, %rax
jle 0x10523
leaq 0x8(%rdi), %rcx
xorl %edx, %edx
leaq (%rdx,%rdx,2), %r9
movq (%rcx,%r9,8), %r8
movq 0x8(%rcx,%r9,8), %r9
cmpq %r9, %r8
je 0x1051b
cmpl %esi, (%r8)
je 0x10550
addq $0x1c, %r8
jmp 0x1050b
incq %rdx
cmpq %rax, %rdx
jne 0x104fe
leaq (%rax,%rax,2), %rax
movq 0x8(%rdi,%rax,8), %rdx
movq 0x10(%rdi,%rax,8), %rcx
cmpq %rcx, %rdx
je 0x10554
addq $0x1c, %rdx
cmpl %esi, -0x1c(%rdx)
sete %al
je 0x10556
leaq 0x1c(%rdx), %rdi
cmpq %rcx, %rdx
movq %rdi, %rdx
jne 0x1053a
jmp 0x10556
movb $0x1, %al
jmp 0x10556
xorl %eax, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/navrajsaini[P]PL_Compiler_design_project/BlockTable.cpp
// Function: BlockTable::define(int, Kind, myType, int, int, int, int)
bool BlockTable::define (int index, Kind nkind, myType ntype, int nsize, int nvalue, int disp, int label)
{
   bool error, newblock_ret;
   TableEntry findtable, a;
   // I will be manipulating findtable for the code generation part.
   //don't need to do anything with it for now.
   findtable = find (index, error);
   if (error)
   {
      //  if (loc(index) == 0)//this is for searching and finding the differnece between the index location
      //and the blockLevel.
      return false;
   }
   else if (findtable.kind == PROCEDURE && search(index))
   {
      return false;
   }
   else
   {
      //create the Table entry
      a.idindex = index;
      a.kind = nkind;
      a.type = ntype;
      a.size = nsize;
      a.value = nvalue;
      a.disp = disp;
      a.procLabel = label;
      //push it to the new vector
      table[blockLevel].push_back(a);
      return true;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %r9d, -0x34(%rbp)
movl %r8d, -0x30(%rbp)
movl %ecx, %r12d
movl %edx, %r13d
movl %esi, %r14d
movq %rdi, %rbx
leaq -0x50(%rbp), %rdi
leaq -0x29(%rbp), %r15
movq %rbx, %rsi
movl %r14d, %edx
movq %r15, %rcx
callq 0x10624
cmpb $0x0, (%r15)
je 0x1059d
xorl %eax, %eax
jmp 0x10614
cmpl $0x3, -0x4c(%rbp)
jne 0x105b2
movq %rbx, %rdi
movl %r14d, %esi
callq 0x104e8
testb %al, %al
jne 0x10599
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %ecx
movl %r14d, -0x50(%rbp)
movl %r13d, -0x4c(%rbp)
movl %r12d, -0x48(%rbp)
movl -0x30(%rbp), %edx
movl %edx, -0x44(%rbp)
movl -0x34(%rbp), %edx
movl %edx, -0x40(%rbp)
movl %ecx, -0x3c(%rbp)
movl %eax, -0x38(%rbp)
movslq 0xf8(%rbx), %rax
leaq (%rax,%rax,2), %rax
leaq (%rbx,%rax,8), %rdi
addq $0x8, %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x10609
movups -0x50(%rbp), %xmm0
movups -0x44(%rbp), %xmm1
movups %xmm1, 0xc(%rsi)
movups %xmm0, (%rsi)
addq $0x1c, 0x8(%rdi)
jmp 0x10612
leaq -0x50(%rbp), %rdx
callq 0x10a9e
movb $0x1, %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/navrajsaini[P]PL_Compiler_design_project/BlockTable.cpp
// Function: BlockTable::find(int, bool&)
TableEntry BlockTable::find (int index, bool &error)
{
   TableEntry a;
   for (int i = 0; i < table[blockLevel].size(); i++)
   {
      if (table[blockLevel][i].idindex == index)
      {
	 error = true;
	 inScope = true;
	 a.idindex = table[blockLevel][i].idindex;
	 a.kind = table[blockLevel][i].kind;
	 a.type = table[blockLevel][i].type;
	 a.size = table[blockLevel][i].size;
	 a.value = table[blockLevel][i].value;
	 a.disp = table[blockLevel][i].disp;
	 a.procLabel = table[blockLevel][i].procLabel;
	 return a;
      }
   }
   error = false;
   inScope = false;
}

// Assembly:
movq %rdi, %rax
movslq 0xf8(%rsi), %rdi
leaq (%rdi,%rdi,2), %r8
movq 0x8(%rsi,%r8,8), %rdi
movq 0x10(%rsi,%r8,8), %r9
subq %rdi, %r9
je 0x106a2
pushq %rbp
movq %rsp, %rbp
sarq $0x2, %r9
movabsq $0x6db6db6db6db6db7, %r8 # imm = 0x6DB6DB6DB6DB6DB7
imulq %r9, %r8
cmpq $0x1, %r8
adcq $0x0, %r8
addq $0x18, %rdi
cmpl %edx, -0x18(%rdi)
je 0x10673
addq $0x1c, %rdi
decq %r8
jne 0x10663
jmp 0x106a1
movb $0x1, %r8b
movb %r8b, (%rcx)
movb %r8b, (%rsi)
movl %edx, (%rax)
movl -0x14(%rdi), %ecx
movl %ecx, 0x4(%rax)
movl -0x10(%rdi), %ecx
movl %ecx, 0x8(%rax)
movl -0xc(%rdi), %ecx
movl %ecx, 0xc(%rax)
movl -0x8(%rdi), %ecx
movl %ecx, 0x10(%rax)
movl -0x4(%rdi), %ecx
movl %ecx, 0x14(%rax)
movl (%rdi), %ecx
movl %ecx, 0x18(%rax)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/navrajsaini[P]PL_Compiler_design_project/BlockTable.cpp
// Function: BlockTable::endBlock()
void BlockTable::endBlock()
{
   //erase all entries in the current block
   table[blockLevel].erase(table[blockLevel].begin(), table[blockLevel].end());
   if (blockLevel > -1)
      blockLevel--;
   else
      ;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq 0xf8(%rdi), %rax
leaq (%rax,%rax,2), %rdx
movq 0x8(%rdi,%rdx,8), %rcx
cmpq 0x10(%rdi,%rdx,8), %rcx
je 0x106eb
leaq (%rdi,%rdx,8), %rdx
addq $0x8, %rdx
movq %rcx, 0x8(%rdx)
testl %eax, %eax
js 0x106f7
decl %eax
movl %eax, 0xf8(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/navrajsaini[P]PL_Compiler_design_project/BlockTable.cpp
// Function: BlockTable::loc(int)
int BlockTable::loc (int index)
{
   for (int i = blockLevel; i >= 0; i--)
   //go through all the blocks from the current block
   {
      for (auto it = table[i].begin(); it != table[i].end(); ++it)
      //check all the entries in the block level
    	 if (it -> idindex == index)
       //if it matches return the differnece in the block levels
    	 {
    	    return (blockLevel - i);
    	 }
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0xf8(%rdi), %eax
addq $0x8, %rdi
movl %eax, %ecx
movl %ecx, %edx
leaq (%rdx,%rdx,2), %r8
movq (%rdi,%r8,8), %rdx
movq 0x8(%rdi,%r8,8), %r8
cmpq %r8, %rdx
je 0x109fe
cmpl %esi, (%rdx)
je 0x10a02
addq $0x1c, %rdx
jmp 0x109ef
decl %ecx
jmp 0x109e0
subl %ecx, %eax
popq %rbp
retq