LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: 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
subq $0xb0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x88(%rbp)
addq $0x5098, %rdi           # imm = 0x5098
leaq 0x7e2b(%rip), %rsi      # 0x1f943
callq 0x2280
movq -0x88(%rbp), %rdi
callq 0x15310
movq -0x88(%rbp), %rdi
addq $0x5050, %rdi           # imm = 0x5050
leaq 0x74df(%rip), %rsi      # 0x1f01d
callq 0x10ea0
testb $0x1, %al
jne 0x17b4c
jmp 0x17d06
movq -0x88(%rbp), %rdi
callq 0x14f20
movq -0x88(%rbp), %rdi
callq 0x174f0
movq -0x88(%rbp), %rax
movq %rax, %rdi
addq $0x4c38, %rdi           # imm = 0x4C38
movl 0x4ddc(%rax), %esi
callq 0x19fe0
testb $0x1, %al
jne 0x17c08
leaq -0x29(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x2350
movq -0x90(%rbp), %rdx
leaq 0x7da0(%rip), %rsi      # 0x1f946
leaq -0x28(%rbp), %rdi
callq 0x2290
jmp 0x17bb1
movq -0x88(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x15400
jmp 0x17bc3
leaq -0x28(%rbp), %rdi
callq 0x2130
leaq -0x29(%rbp), %rdi
callq 0x21e0
jmp 0x17c08
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x17bfa
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2130
leaq -0x29(%rbp), %rdi
callq 0x21e0
jmp 0x17d0f
movq -0x88(%rbp), %rax
movq %rax, %rsi
addq $0x4c38, %rsi           # imm = 0x4C38
movl 0x4ddc(%rax), %edx
leaq -0x58(%rbp), %rdi
callq 0x1a870
movq -0x88(%rbp), %rax
movups -0x58(%rbp), %xmm0
movups -0x4c(%rbp), %xmm1
movups %xmm1, 0x4e1c(%rax)
movups %xmm0, 0x4e10(%rax)
addq $0x50c0, %rax           # imm = 0x50C0
movq %rax, -0xa0(%rbp)
leaq -0x79(%rbp), %rdi
movq %rdi, -0x98(%rbp)
callq 0x2350
movq -0x98(%rbp), %rdx
leaq 0x7cf8(%rip), %rsi      # 0x1f968
leaq -0x78(%rbp), %rdi
callq 0x2290
jmp 0x17c7b
movq -0x88(%rbp), %rax
movq %rax, %rdi
addq $0x4c38, %rdi           # imm = 0x4C38
movl 0x4ddc(%rax), %esi
callq 0x1a790
movl %eax, -0xa4(%rbp)
jmp 0x17c9f
movl -0xa4(%rbp), %edx
movq -0xa0(%rbp), %rdi
movq -0x88(%rbp), %rax
movl 0x4e28(%rax), %ecx
leaq -0x78(%rbp), %rsi
callq 0x13010
jmp 0x17cc4
leaq -0x78(%rbp), %rdi
callq 0x2130
leaq -0x79(%rbp), %rdi
callq 0x21e0
jmp 0x17d06
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x17cfb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x2130
leaq -0x79(%rbp), %rdi
callq 0x21e0
jmp 0x17d0f
addq $0xb0, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x2340
nopl (%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x5098, %rdi           # imm = 0x5098
leaq 0x765e(%rip), %rsi      # 0x1f920
callq 0x2280
movq -0x10(%rbp), %rdi
callq 0x15310
movq -0x10(%rbp), %rdi
addq $0x5050, %rdi           # imm = 0x5050
leaq 0x7096(%rip), %rsi      # 0x1f378
callq 0x10ea0
testb $0x1, %al
jne 0x182ed
jmp 0x1831f
movq -0x10(%rbp), %rdi
movl 0x71f0(%rdi), %eax
addl $0x1, %eax
movl %eax, 0x71f0(%rdi)
movl 0x71f8(%rdi), %eax
addl $0x1, %eax
movl %eax, 0x71f8(%rdi)
callq 0x18330
movq -0x10(%rbp), %rdi
callq 0x18660
jmp 0x18328
movq -0x10(%rbp), %rdi
callq 0x15110
addq $0x10, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x5098, %rdi           # imm = 0x5098
leaq 0x72a2(%rip), %rsi      # 0x1f924
callq 0x2280
movq -0x10(%rbp), %rdi
callq 0x15310
movq -0x10(%rbp), %rdi
addq $0x5050, %rdi           # imm = 0x5050
leaq 0x6cc3(%rip), %rsi      # 0x1f365
callq 0x10ea0
testb $0x1, %al
jne 0x186ad
jmp 0x186e8
movq -0x10(%rbp), %rdi
movl 0x71f0(%rdi), %eax
addl $0x1, %eax
movl %eax, 0x71f0(%rdi)
movl 0x71f8(%rdi), %eax
addl $0x1, %eax
movl %eax, 0x71f8(%rdi)
callq 0x14f20
movq -0x10(%rbp), %rdi
callq 0x18330
movq -0x10(%rbp), %rdi
callq 0x18660
jmp 0x186ea
jmp 0x186ea
addq $0x10, %rsp
popq %rbp
retq
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x5098, %rdi           # imm = 0x5098
leaq 0x7220(%rip), %rsi      # 0x1f932
callq 0x2280
movq -0x10(%rbp), %rdi
callq 0x15310
movq -0x10(%rbp), %rdi
addq $0x5050, %rdi           # imm = 0x5050
leaq 0x6b9e(%rip), %rsi      # 0x1f2d0
callq 0x11240
testb $0x1, %al
jne 0x1873d
jmp 0x1873f
jmp 0x1873f
movq -0x10(%rbp), %rdi
movl 0x71f4(%rdi), %eax
addl $0x1, %eax
movl %eax, 0x71f4(%rdi)
callq 0x18770
movq -0x10(%rbp), %rdi
callq 0x187c0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x5098, %rdi           # imm = 0x5098
leaq 0x7153(%rip), %rsi      # 0x1f935
callq 0x2280
movq -0x10(%rbp), %rdi
callq 0x15310
movq -0x10(%rbp), %rdi
addq $0x5050, %rdi           # imm = 0x5050
leaq 0x6b63(%rip), %rsi      # 0x1f365
callq 0x10ea0
testb $0x1, %al
jne 0x1880d
jmp 0x18839
movq -0x10(%rbp), %rdi
movl 0x71f4(%rdi), %eax
addl $0x1, %eax
movl %eax, 0x71f4(%rdi)
callq 0x14f20
movq -0x10(%rbp), %rdi
callq 0x18770
movq -0x10(%rbp), %rdi
callq 0x187c0
jmp 0x1883b
jmp 0x1883b
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x5098, %rdi           # imm = 0x5098
leaq 0x6e14(%rip), %rsi      # 0x1f97d
callq 0x2280
movq -0x20(%rbp), %rdi
callq 0x15310
movq -0x20(%rbp), %rdi
addq $0x5050, %rdi           # imm = 0x5050
leaq 0x6c33(%rip), %rsi      # 0x1f7bc
callq 0x10ea0
testb $0x1, %al
jne 0x18baf
movq -0x20(%rbp), %rdi
addq $0x5050, %rdi           # imm = 0x5050
leaq 0x67cb(%rip), %rsi      # 0x1f36f
callq 0x10ea0
testb $0x1, %al
jne 0x18baf
jmp 0x18c26
movq -0x20(%rbp), %rdi
callq 0x14f20
movq -0x20(%rbp), %rdi
addq $0x5050, %rdi           # imm = 0x5050
leaq 0x67a6(%rip), %rsi      # 0x1f370
callq 0x10ea0
testb $0x1, %al
jne 0x18bf0
movq -0x20(%rbp), %rdi
addq $0x5070, %rdi           # imm = 0x5070
leaq 0x678a(%rip), %rsi      # 0x1f36f
callq 0x10ea0
testb $0x1, %al
jne 0x18bf0
jmp 0x18c1b
movq -0x20(%rbp), %rdi
callq 0x14f20
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x188b0
movq -0x20(%rbp), %rdi
movq -0x10(%rbp), %rsi
movl -0x14(%rbp), %edx
callq 0x18b40
jmp 0x18c24
movq -0x20(%rbp), %rdi
callq 0x15110
jmp 0x18c28
jmp 0x18c28
addq $0x20, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x5098, %rdi           # imm = 0x5098
leaq 0x6cfb(%rip), %rsi      # 0x1f99d
callq 0x2280
movq -0x10(%rbp), %rdi
callq 0x15310
movq -0x10(%rbp), %rdi
addq $0x5050, %rdi           # imm = 0x5050
leaq 0x66a7(%rip), %rsi      # 0x1f369
callq 0x10ea0
testb $0x1, %al
jne 0x18ce8
movq -0x10(%rbp), %rdi
addq $0x5050, %rdi           # imm = 0x5050
leaq 0x668a(%rip), %rsi      # 0x1f367
callq 0x10ea0
testb $0x1, %al
jne 0x18ce8
jmp 0x18d05
movq -0x10(%rbp), %rdi
callq 0x18d10
movq -0x10(%rbp), %rdi
callq 0x18c30
movq -0x10(%rbp), %rdi
callq 0x18c80
jmp 0x18d07
jmp 0x18d07
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
addq $0x5098, %rdi           # imm = 0x5098
leaq 0x6c5a(%rip), %rsi      # 0x1f98f
callq 0x2280
movq -0x70(%rbp), %rdi
callq 0x15310
movq -0x70(%rbp), %rdi
addq $0x5050, %rdi           # imm = 0x5050
leaq 0x6612(%rip), %rsi      # 0x1f367
callq 0x10ea0
testb $0x1, %al
jne 0x18d63
jmp 0x18df4
movq -0x70(%rbp), %rax
addq $0x50c0, %rax           # imm = 0x50C0
movq %rax, -0x80(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x2350
movq -0x78(%rbp), %rdx
leaq 0x6c09(%rip), %rsi      # 0x1f992
leaq -0x28(%rbp), %rdi
callq 0x2290
jmp 0x18d94
movq -0x80(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x12ef0
jmp 0x18da3
leaq -0x28(%rbp), %rdi
callq 0x2130
leaq -0x29(%rbp), %rdi
callq 0x21e0
movq -0x70(%rbp), %rdi
callq 0x14f20
jmp 0x18eb6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x18de6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2130
leaq -0x29(%rbp), %rdi
callq 0x21e0
jmp 0x18ebf
movq -0x70(%rbp), %rdi
addq $0x5050, %rdi           # imm = 0x5050
leaq 0x6563(%rip), %rsi      # 0x1f369
callq 0x10ea0
testb $0x1, %al
jne 0x18e14
jmp 0x18eab
movq -0x70(%rbp), %rax
addq $0x50c0, %rax           # imm = 0x50C0
movq %rax, -0x90(%rbp)
leaq -0x61(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x2350
movq -0x88(%rbp), %rdx
leaq 0x6b53(%rip), %rsi      # 0x1f996
leaq -0x60(%rbp), %rdi
callq 0x2290
jmp 0x18e4e
movq -0x90(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x12ef0
jmp 0x18e60
leaq -0x60(%rbp), %rdi
callq 0x2130
leaq -0x61(%rbp), %rdi
callq 0x21e0
movq -0x70(%rbp), %rdi
callq 0x14f20
jmp 0x18eb4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x18ea0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x2130
leaq -0x61(%rbp), %rdi
callq 0x21e0
jmp 0x18ebf
movq -0x70(%rbp), %rdi
callq 0x15110
jmp 0x18eb6
addq $0x90, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x2340
nopl (%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x5098, %rdi           # imm = 0x5098
leaq 0x6ac4(%rip), %rsi      # 0x1f9b6
callq 0x2280
movq -0x10(%rbp), %rdi
callq 0x15310
movq -0x10(%rbp), %rdi
callq 0x19290
movq -0x10(%rbp), %rdi
callq 0x192f0
movq -0x10(%rbp), %rdi
callq 0x19340
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x5098, %rdi           # imm = 0x5098
leaq 0x6a4a(%rip), %rsi      # 0x1f99c
callq 0x2280
movq -0x10(%rbp), %rdi
callq 0x15310
movq -0x10(%rbp), %rdi
addq $0x5050, %rdi           # imm = 0x5050
leaq 0x63fb(%rip), %rsi      # 0x1f36d
callq 0x10ea0
testb $0x1, %al
jne 0x18fb3
movq -0x10(%rbp), %rdi
addq $0x5050, %rdi           # imm = 0x5050
leaq 0x63e6(%rip), %rsi      # 0x1f373
callq 0x10ea0
testb $0x1, %al
jne 0x18fb3
movq -0x10(%rbp), %rdi
addq $0x5050, %rdi           # imm = 0x5050
leaq 0x63ce(%rip), %rsi      # 0x1f376
callq 0x10ea0
testb $0x1, %al
jne 0x18fb3
jmp 0x18fc7
movq -0x10(%rbp), %rdi
callq 0x18fd0
movq -0x10(%rbp), %rdi
callq 0x18ed0
jmp 0x18fc9
jmp 0x18fc9
addq $0x10, %rsp
popq %rbp
retq
nop
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x5098, %rdi           # imm = 0x5098
leaq 0x66fa(%rip), %rsi      # 0x1f9ac
callq 0x2280
movq -0x10(%rbp), %rdi
callq 0x15310
movq -0x10(%rbp), %rdi
addq $0x5050, %rdi           # imm = 0x5050
leaq 0x5ffe(%rip), %rsi      # 0x1f2d0
callq 0x10ea0
testb $0x1, %al
jne 0x192dd
jmp 0x192e8
movq -0x10(%rbp), %rdi
callq 0x14f20
jmp 0x192ea
jmp 0x192ea
addq $0x10, %rsp
popq %rbp
retq
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x5098, %rdi           # imm = 0x5098
leaq 0x6657(%rip), %rsi      # 0x1f9b9
callq 0x2280
movq -0x10(%rbp), %rdi
callq 0x15310
movq -0x10(%rbp), %rdi
addq $0x5050, %rdi           # imm = 0x5050
leaq 0x5f4e(%rip), %rsi      # 0x1f2d0
callq 0x10ea0
testb $0x1, %al
jne 0x193a8
movq -0x10(%rbp), %rdi
addq $0x5050, %rdi           # imm = 0x5050
leaq 0x5f31(%rip), %rsi      # 0x1f2ce
callq 0x10ea0
testb $0x1, %al
jne 0x193a8
jmp 0x193c5
movq -0x10(%rbp), %rdi
callq 0x193d0
movq -0x10(%rbp), %rdi
callq 0x192f0
movq -0x10(%rbp), %rdi
callq 0x19340
jmp 0x193c7
jmp 0x193c7
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x90, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x70(%rbp)
addq $0x5098, %rdi           # imm = 0x5098
leaq 0x65c8(%rip), %rsi      # 0x1f9bd
callq 0x2280
movq -0x70(%rbp), %rdi
callq 0x15310
movq -0x70(%rbp), %rdi
addq $0x5050, %rdi           # imm = 0x5050
leaq 0x5eb9(%rip), %rsi      # 0x1f2ce
callq 0x10ea0
testb $0x1, %al
jne 0x19423
jmp 0x194b4
movq -0x70(%rbp), %rax
addq $0x50c0, %rax           # imm = 0x50C0
movq %rax, -0x80(%rbp)
leaq -0x29(%rbp), %rdi
movq %rdi, -0x78(%rbp)
callq 0x2350
movq -0x78(%rbp), %rdx
leaq 0x6577(%rip), %rsi      # 0x1f9c0
leaq -0x28(%rbp), %rdi
callq 0x2290
jmp 0x19454
movq -0x80(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x12ef0
jmp 0x19463
leaq -0x28(%rbp), %rdi
callq 0x2130
leaq -0x29(%rbp), %rdi
callq 0x21e0
movq -0x70(%rbp), %rdi
callq 0x14f20
jmp 0x19576
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x194a6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x28(%rbp), %rdi
callq 0x2130
leaq -0x29(%rbp), %rdi
callq 0x21e0
jmp 0x1957f
movq -0x70(%rbp), %rdi
addq $0x5050, %rdi           # imm = 0x5050
leaq 0x5e0a(%rip), %rsi      # 0x1f2d0
callq 0x10ea0
testb $0x1, %al
jne 0x194d4
jmp 0x1956b
movq -0x70(%rbp), %rax
addq $0x50c0, %rax           # imm = 0x50C0
movq %rax, -0x90(%rbp)
leaq -0x61(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x2350
movq -0x88(%rbp), %rdx
leaq 0x64c1(%rip), %rsi      # 0x1f9c4
leaq -0x60(%rbp), %rdi
callq 0x2290
jmp 0x1950e
movq -0x90(%rbp), %rdi
leaq -0x60(%rbp), %rsi
callq 0x12ef0
jmp 0x19520
leaq -0x60(%rbp), %rdi
callq 0x2130
leaq -0x61(%rbp), %rdi
callq 0x21e0
movq -0x70(%rbp), %rdi
callq 0x14f20
jmp 0x19574
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
jmp 0x19560
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x38(%rbp)
movl %eax, -0x3c(%rbp)
leaq -0x60(%rbp), %rdi
callq 0x2130
leaq -0x61(%rbp), %rdi
callq 0x21e0
jmp 0x1957f
movq -0x70(%rbp), %rdi
callq 0x15110
jmp 0x19576
addq $0x90, %rsp
popq %rbp
retq
movq -0x38(%rbp), %rdi
callq 0x2340
nopl (%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x5098, %rdi           # imm = 0x5098
leaq 0x608b(%rip), %rsi      # 0x1f9cd
callq 0x2280
movq -0x10(%rbp), %rdi
callq 0x15310
movq -0x10(%rbp), %rdi
addq $0x5050, %rdi           # imm = 0x5050
leaq 0x5970(%rip), %rsi      # 0x1f2d2
callq 0x10ea0
testb $0x1, %al
jne 0x199a3
movq -0x10(%rbp), %rdi
addq $0x5050, %rdi           # imm = 0x5050
leaq 0x594d(%rip), %rsi      # 0x1f2ca
callq 0x10ea0
testb $0x1, %al
jne 0x199a3
movq -0x10(%rbp), %rdi
addq $0x5050, %rdi           # imm = 0x5050
leaq 0x5930(%rip), %rsi      # 0x1f2c8
callq 0x10ea0
testb $0x1, %al
jne 0x199a3
jmp 0x199c0
movq -0x10(%rbp), %rdi
callq 0x199d0
movq -0x10(%rbp), %rdi
callq 0x19590
movq -0x10(%rbp), %rdi
callq 0x19920
jmp 0x199c2
jmp 0x199c2
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x5098, %rdi           # imm = 0x5098
leaq 0x5d7f(%rip), %rsi      # 0x1fa31
callq 0x2280
movq -0x10(%rbp), %rdi
callq 0x15310
movq -0x10(%rbp), %rdi
addq $0x5050, %rdi           # imm = 0x5050
leaq 0x5aea(%rip), %rsi      # 0x1f7bc
callq 0x10ea0
testb $0x1, %al
jne 0x19cdd
jmp 0x19cf2
movq -0x10(%rbp), %rdi
movl $0x1, 0x71b4(%rdi)
callq 0x19d00
jmp 0x19cf4
jmp 0x19cf4
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x5098, %rdi           # imm = 0x5098
leaq 0x5c4b(%rip), %rsi      # 0x1f96d
callq 0x2280
movq -0x10(%rbp), %rdi
callq 0x15310
movq -0x10(%rbp), %rdi
addq $0x5050, %rdi           # imm = 0x5050
leaq 0x5a7a(%rip), %rsi      # 0x1f7bc
callq 0x10ea0
testb $0x1, %al
jne 0x19d4d
jmp 0x19d87
movq -0x10(%rbp), %rdi
callq 0x14f20
movq -0x10(%rbp), %rdi
callq 0x18770
movq -0x10(%rbp), %rdi
addq $0x5050, %rdi           # imm = 0x5050
leaq 0x55ff(%rip), %rsi      # 0x1f370
callq 0x10ea0
testb $0x1, %al
jne 0x19d7c
jmp 0x19d85
movq -0x10(%rbp), %rdi
callq 0x14f20
jmp 0x19d87
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x5098, %rdi           # imm = 0x5098
leaq 0x5c8a(%rip), %rsi      # 0x1fa3c
callq 0x2280
movq -0x10(%rbp), %rdi
callq 0x15310
movq -0x10(%rbp), %rdi
addq $0x5050, %rdi           # imm = 0x5050
leaq 0x54f2(%rip), %rsi      # 0x1f2c4
callq 0x10ea0
testb $0x1, %al
jne 0x19ddd
jmp 0x19e14
movq -0x10(%rbp), %rdi
movq %rdi, %rax
addq $0x2030, %rax           # imm = 0x2030
movslq 0x2028(%rdi), %rcx
imulq $0xc, %rcx, %rcx
addq %rcx, %rax
movl 0x8(%rax), %eax
movl %eax, 0x4de4(%rdi)
movl 0x4de4(%rdi), %eax
movl %eax, 0x7228(%rdi)
callq 0x14f20
jmp 0x19e1d
movq -0x10(%rbp), %rdi
callq 0x15110
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
addq $0x5098, %rdi           # imm = 0x5098
leaq 0x5be3(%rip), %rsi      # 0x1fa35
callq 0x2280
movq -0x10(%rbp), %rdi
callq 0x15310
movq -0x10(%rbp), %rdi
addq $0x5050, %rdi           # imm = 0x5050
leaq 0x54e8(%rip), %rsi      # 0x1f35a
callq 0x10ea0
testb $0x1, %al
jne 0x19e7d
jmp 0x19eb0
movq -0x10(%rbp), %rdi
movl $0x0, 0x4de4(%rdi)
movslq 0x4d88(%rdi), %rax
movl $0x0, 0x4d60(%rdi,%rax,4)
movl 0x4de4(%rdi), %eax
movl %eax, 0x7228(%rdi)
callq 0x14f20
jmp 0x19f0b
movq -0x10(%rbp), %rdi
addq $0x5050, %rdi           # imm = 0x5050
leaq 0x549e(%rip), %rsi      # 0x1f360
callq 0x10ea0
testb $0x1, %al
jne 0x19ecd
jmp 0x19f00
movq -0x10(%rbp), %rdi
movl $0x1, 0x4de4(%rdi)
movslq 0x4d88(%rdi), %rax
movl $0x1, 0x4d60(%rdi,%rax,4)
movl 0x4de4(%rdi), %eax
movl %eax, 0x7228(%rdi)
callq 0x14f20
jmp 0x19f09
movq -0x10(%rbp), %rdi
callq 0x15110
jmp 0x19f0b
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: 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
subq $0x50, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x48(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x48(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0xf8(%rcx), %eax
jge 0x1a098
movq -0x48(%rbp), %rdi
addq $0x8, %rdi
movslq -0x1c(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
callq 0x1ab80
movq %rax, -0x28(%rbp)
movq -0x48(%rbp), %rdi
addq $0x8, %rdi
movslq -0x1c(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
callq 0x1abf0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x1abb0
testb $0x1, %al
jne 0x1a05c
jmp 0x1a088
leaq -0x28(%rbp), %rdi
callq 0x1ac20
movl (%rax), %eax
movl %eax, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jne 0x1a07b
movb $0x1, -0x1(%rbp)
jmp 0x1a116
jmp 0x1a07d
leaq -0x28(%rbp), %rdi
callq 0x1ac40
jmp 0x1a02d
jmp 0x1a08a
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x19ffe
movq -0x48(%rbp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movslq 0xf8(%rax), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
callq 0x1ab80
movq %rax, -0x38(%rbp)
movq -0x48(%rbp), %rax
movq %rax, %rdi
addq $0x8, %rdi
movslq 0xf8(%rax), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
callq 0x1abf0
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x1abb0
testb $0x1, %al
jne 0x1a0ef
jmp 0x1a112
leaq -0x38(%rbp), %rdi
callq 0x1ac20
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x1a105
movb $0x1, -0x1(%rbp)
jmp 0x1a116
jmp 0x1a107
leaq -0x38(%rbp), %rdi
callq 0x1ac40
jmp 0x1a0ba
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x90, %rsp
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %eax
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movl %ecx, -0x1c(%rbp)
movl %r8d, -0x20(%rbp)
movl %r9d, -0x24(%rbp)
movq -0x10(%rbp), %rsi
movq %rsi, -0x88(%rbp)
movl -0x14(%rbp), %edx
leaq -0x7c(%rbp), %rdi
leaq -0x25(%rbp), %rcx
callq 0x1a220
movq -0x7c(%rbp), %rax
movq %rax, -0x44(%rbp)
movq -0x74(%rbp), %rax
movq %rax, -0x3c(%rbp)
movq -0x6c(%rbp), %rax
movq %rax, -0x34(%rbp)
movl -0x64(%rbp), %eax
movl %eax, -0x2c(%rbp)
testb $0x1, -0x25(%rbp)
je 0x1a19b
movb $0x0, -0x1(%rbp)
jmp 0x1a20f
cmpl $0x3, -0x40(%rbp)
jne 0x1a1bc
movq -0x88(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x19fe0
testb $0x1, %al
jne 0x1a1b6
jmp 0x1a1bc
movb $0x0, -0x1(%rbp)
jmp 0x1a20f
movq -0x88(%rbp), %rax
movl -0x14(%rbp), %ecx
movl %ecx, -0x60(%rbp)
movl -0x18(%rbp), %ecx
movl %ecx, -0x5c(%rbp)
movl -0x1c(%rbp), %ecx
movl %ecx, -0x58(%rbp)
movl -0x20(%rbp), %ecx
movl %ecx, -0x54(%rbp)
movl -0x24(%rbp), %ecx
movl %ecx, -0x50(%rbp)
movl 0x10(%rbp), %ecx
movl %ecx, -0x4c(%rbp)
movl 0x18(%rbp), %ecx
movl %ecx, -0x48(%rbp)
movq %rax, %rdi
addq $0x8, %rdi
movslq 0xf8(%rax), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
leaq -0x60(%rbp), %rsi
callq 0x1ac60
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x90, %rsp
popq %rbp
retq
nopl (%rax)
// File: navrajsaini[P]PL_Compiler_design_project/BlockTable.cpp
// Function: BlockTable::newBlock()
bool BlockTable::newBlock()
{
   if(blockLevel+1 > MAXBLOCK)//check if blockLevel+1 is > 10
      return false;
   else//if it isn't increment blockLevel and return true
   {
      blockLevel++;
      return true;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x18(%rbp)
movl 0xf8(%rax), %eax
addl $0x1, %eax
cmpl $0xa, %eax
jle 0x1a454
movb $0x0, -0x1(%rbp)
jmp 0x1a46b
movq -0x18(%rbp), %rax
movl 0xf8(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xf8(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl 0xf8(%rax), %eax
movl %eax, -0x10(%rbp)
cmpl $0x0, -0x10(%rbp)
jl 0x1a845
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
movslq -0x10(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
callq 0x1ab80
movq %rax, -0x18(%rbp)
movq -0x28(%rbp), %rdi
addq $0x8, %rdi
movslq -0x10(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
callq 0x1abf0
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x20(%rbp), %rsi
callq 0x1abb0
testb $0x1, %al
jne 0x1a805
jmp 0x1a835
leaq -0x18(%rbp), %rdi
callq 0x1ac20
movl (%rax), %eax
cmpl -0xc(%rbp), %eax
jne 0x1a828
movq -0x28(%rbp), %rax
movl 0xf8(%rax), %eax
subl -0x10(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
jmp 0x1a82a
leaq -0x18(%rbp), %rdi
callq 0x1ac40
jmp 0x1a7d6
jmp 0x1a837
movl -0x10(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x1a7b0
ud2
nopw (%rax,%rax)
// File: navrajsaini[P]PL_Compiler_design_project/Assembler.cpp
// Function: Assembler::Assembler(std::istream&, std::ostream&)
Assembler::Assembler(istream &in, ostream &out)
{
   currentAddress = 0;
   for (int i = 0; i < MAXLABEL; i++)
      labelTable[i] = 0;
   insource = &in;
   outsource = &out;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, 0x7d0(%rax)
movl $0x0, -0x1c(%rbp)
cmpl $0x1f4, -0x1c(%rbp)     # imm = 0x1F4
jge 0x1bbcc
movq -0x28(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1bba9
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rcx
movq %rcx, 0x7d8(%rax)
movq -0x18(%rbp), %rcx
movq %rcx, 0x7e0(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: navrajsaini[P]PL_Compiler_design_project/interp.cpp
// Function: Interpreter::Interpreter(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, bool)
Interpreter::Interpreter( string filename, bool step)
{
//  this->stepping = step;
  stepping = step;
  cout << " Loading..." << endl;
  load_program(filename);
  cout << " Running ..." << endl;
  run_program();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rsi, -0x60(%rbp)
movb %dl, %al
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
andb $0x1, %al
movb %al, -0x11(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movb -0x11(%rbp), %cl
andb $0x1, %cl
movb %cl, 0xfb5(%rax)
movq 0x9dc2(%rip), %rdi      # 0x26fc8
leaq 0x293f(%rip), %rsi      # 0x1fb4c
callq 0x21b0
movq %rax, %rdi
movq 0x9d9c(%rip), %rsi      # 0x26fb8
callq 0x21d0
movq -0x60(%rbp), %rsi
leaq -0x38(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x20d0
movq -0x58(%rbp), %rdi
movq -0x50(%rbp), %rsi
callq 0x1d2a0
jmp 0x1d241
leaq -0x38(%rbp), %rdi
callq 0x2130
movq 0x9d77(%rip), %rdi      # 0x26fc8
leaq 0x2900(%rip), %rsi      # 0x1fb58
callq 0x21b0
movq %rax, %rdi
movq 0x9d51(%rip), %rsi      # 0x26fb8
callq 0x21d0
movq -0x58(%rbp), %rdi
callq 0x1d530
addq $0x60, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x2130
movq -0x40(%rbp), %rdi
callq 0x2340
nopl (%rax)
// File: navrajsaini[P]PL_Compiler_design_project/interp.cpp
// Function: Interpreter::runtime_error(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
void Interpreter::runtime_error( string  message, int line_number)
{
  if ( line_number != -1)
     cerr << "line " << line_number << " : " << message << endl;
  else
     cerr << message << endl;
  running = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rsi, -0x28(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
cmpl $-0x1, -0x14(%rbp)
je 0x1d96f
movq 0x96c4(%rip), %rdi      # 0x26ff0
leaq 0x1e32(%rip), %rsi      # 0x1f765
callq 0x21b0
movq %rax, %rdi
movl -0x14(%rbp), %esi
callq 0x2320
movq %rax, %rdi
leaq 0x1e43(%rip), %rsi      # 0x1f790
callq 0x21b0
movq -0x28(%rbp), %rsi
movq %rax, %rdi
callq 0x2190
movq %rax, %rdi
movq 0x9650(%rip), %rsi      # 0x26fb8
callq 0x21d0
jmp 0x1d98e
movq -0x28(%rbp), %rsi
movq 0x9676(%rip), %rdi      # 0x26ff0
callq 0x2190
movq %rax, %rdi
movq 0x962f(%rip), %rsi      # 0x26fb8
callq 0x21d0
movq -0x20(%rbp), %rax
movb $0x0, 0xfb4(%rax)
addq $0x30, %rsp
popq %rbp
retq
nop
// File: navrajsaini[P]PL_Compiler_design_project/interp.cpp
// Function: Interpreter::variable(int, int)
void Interpreter::variable( int level, int displacement)
{
  int x;

  allocate(1);
  x = base_register;
  
  while ( level > 0)
  {
    x = store[x];
    --level;
  }
  store[stack_register] = x + displacement;
  program_register += 3;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movl $0x1, %esi
callq 0x1d9a0
movq -0x20(%rbp), %rax
movl 0xfac(%rax), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0xc(%rbp)
jle 0x1dab0
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1da91
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %edx
addl -0x10(%rbp), %edx
movslq 0xfa8(%rax), %rcx
movl %edx, (%rax,%rcx,4)
movl 0xfb0(%rax), %ecx
addl $0x3, %ecx
movl %ecx, 0xfb0(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: navrajsaini[P]PL_Compiler_design_project/interp.cpp
// Function: Interpreter::index(int, int)
void Interpreter::index( int bound, int line_number)
{
  int i = store[stack_register];
  --stack_register;

  if (i < 1 || i > bound)
     runtime_error(" range error", line_number);
  else
     store[stack_register] = store[stack_register] + i -1;
  program_register += 3;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movslq 0xfa8(%rax), %rcx
movl (%rax,%rcx,4), %ecx
movl %ecx, -0x14(%rbp)
movl 0xfa8(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0xfa8(%rax)
cmpl $0x1, -0x14(%rbp)
jl 0x1db24
movl -0x14(%rbp), %eax
cmpl -0xc(%rbp), %eax
jle 0x1db9b
leaq -0x39(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x2350
movq -0x60(%rbp), %rdx
leaq 0x2039(%rip), %rsi      # 0x1fb75
leaq -0x38(%rbp), %rdi
callq 0x2290
jmp 0x1db47
movq -0x58(%rbp), %rdi
movl -0x10(%rbp), %edx
leaq -0x38(%rbp), %rsi
callq 0x1d900
jmp 0x1db59
leaq -0x38(%rbp), %rdi
callq 0x2130
leaq -0x39(%rbp), %rdi
callq 0x21e0
jmp 0x1dbb9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x1db90
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x2130
leaq -0x39(%rbp), %rdi
callq 0x21e0
jmp 0x1dbd2
movq -0x58(%rbp), %rax
movslq 0xfa8(%rax), %rcx
movl (%rax,%rcx,4), %edx
addl -0x14(%rbp), %edx
subl $0x1, %edx
movslq 0xfa8(%rax), %rcx
movl %edx, (%rax,%rcx,4)
movq -0x58(%rbp), %rax
movl 0xfb0(%rax), %ecx
addl $0x3, %ecx
movl %ecx, 0xfb0(%rax)
addq $0x60, %rsp
popq %rbp
retq
movq -0x48(%rbp), %rdi
callq 0x2340
nopl (%rax,%rax)
// File: navrajsaini[P]PL_Compiler_design_project/interp.cpp
// Function: Interpreter::less()
void Interpreter::less()
{
  ++program_register;
  --stack_register;
  store[stack_register] = ( store[stack_register] < 
                          store[stack_register + 1 ]);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl 0xfb0(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xfb0(%rax)
movl 0xfa8(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0xfa8(%rax)
movslq 0xfa8(%rax), %rcx
movl (%rax,%rcx,4), %ecx
movl 0xfa8(%rax), %edx
addl $0x1, %edx
movslq %edx, %rdx
cmpl (%rax,%rdx,4), %ecx
setl %cl
andb $0x1, %cl
movzbl %cl, %edx
movslq 0xfa8(%rax), %rcx
movl %edx, (%rax,%rcx,4)
popq %rbp
retq
nopl (%rax,%rax)
// File: navrajsaini[P]PL_Compiler_design_project/interp.cpp
// Function: Interpreter::pland()
void Interpreter::pland()
{
  ++program_register;
  --stack_register;
  if (store[stack_register] == 1)
    store[stack_register] = store[stack_register + 1];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl 0xfb0(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xfb0(%rax)
movl 0xfa8(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0xfa8(%rax)
movslq 0xfa8(%rax), %rcx
cmpl $0x1, (%rax,%rcx,4)
jne 0x1e008
movq -0x10(%rbp), %rax
movl 0xfa8(%rax), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %edx
movslq 0xfa8(%rax), %rcx
movl %edx, (%rax,%rcx,4)
popq %rbp
retq
nopw (%rax,%rax)
// File: navrajsaini[P]PL_Compiler_design_project/interp.cpp
// Function: Interpreter::plor()
void Interpreter::plor()
{
  ++program_register;
  --stack_register;
  if (store[stack_register] == 0)
    store[stack_register] = store[stack_register + 1];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl 0xfb0(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0xfb0(%rax)
movl 0xfa8(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0xfa8(%rax)
movslq 0xfa8(%rax), %rcx
cmpl $0x0, (%rax,%rcx,4)
jne 0x1e068
movq -0x10(%rbp), %rax
movl 0xfa8(%rax), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %edx
movslq 0xfa8(%rax), %rcx
movl %edx, (%rax,%rcx,4)
popq %rbp
retq
nopw (%rax,%rax)
// File: navrajsaini[P]PL_Compiler_design_project/interp.cpp
// Function: Interpreter::read(int)
void Interpreter::read(int count)
{
  int x;
//  cout << "program_register = " << program_register << endl;
//  cout << "stack_register = " << stack_register << endl;
//  cout << "base_register = " << base_register << endl;
  program_register += 2;
  stack_register -= count;
  x = stack_register;
//  cout << "Count = " << count;
  while ( x < stack_register + count)
  {
    ++x;
    cout << "Input: ";
    cin >> ( store[ store[x] ] );
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl 0xfb0(%rax), %ecx
addl $0x2, %ecx
movl %ecx, 0xfb0(%rax)
movl -0xc(%rbp), %edx
movl 0xfa8(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0xfa8(%rax)
movl 0xfa8(%rax), %eax
movl %eax, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movl -0x10(%rbp), %eax
movl 0xfa8(%rcx), %ecx
addl -0xc(%rbp), %ecx
cmpl %ecx, %eax
jge 0x1e101
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movq 0x8ef4(%rip), %rdi      # 0x26fc8
leaq 0x1aa7(%rip), %rsi      # 0x1fb82
callq 0x21b0
movq -0x18(%rbp), %rsi
movslq -0x10(%rbp), %rax
movslq (%rsi,%rax,4), %rax
shlq $0x2, %rax
addq %rax, %rsi
movq 0x8ede(%rip), %rdi      # 0x26fd8
callq 0x2120
jmp 0x1e0b0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: navrajsaini[P]PL_Compiler_design_project/interp.cpp
// Function: Interpreter::write(int)
void Interpreter::write (int count)
{
  int x;
  program_register += 2;
  stack_register -= count;
  x = stack_register;

  while (x < stack_register + count )
  {
    ++x;
    cout << "  Output: ";
    cout << ( store[x]) << endl;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl 0xfb0(%rax), %ecx
addl $0x2, %ecx
movl %ecx, 0xfb0(%rax)
movl -0xc(%rbp), %edx
movl 0xfa8(%rax), %ecx
subl %edx, %ecx
movl %ecx, 0xfa8(%rax)
movl 0xfa8(%rax), %eax
movl %eax, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movl -0x10(%rbp), %eax
movl 0xfa8(%rcx), %ecx
addl -0xc(%rbp), %ecx
cmpl %ecx, %eax
jge 0x1e1a8
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
movq 0x8e54(%rip), %rdi      # 0x26fc8
leaq 0x1a0f(%rip), %rsi      # 0x1fb8a
callq 0x21b0
movq -0x18(%rbp), %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %esi
movq 0x8e36(%rip), %rdi      # 0x26fc8
callq 0x2320
movq %rax, %rdi
movq 0x8e17(%rip), %rsi      # 0x26fb8
callq 0x21d0
jmp 0x1e150
addq $0x20, %rsp
popq %rbp
retq
nop
// File: navrajsaini[P]PL_Compiler_design_project/interp.cpp
// Function: Interpreter::assign(int)
void Interpreter::assign (int count)
{
  int x;
  
  program_register += 2;
  stack_register = stack_register - 2*count;
  x = stack_register;

  while ( x < stack_register + count)
  {
    ++x;
    store[store[x]] = store[x + count];
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl 0xfb0(%rax), %ecx
addl $0x2, %ecx
movl %ecx, 0xfb0(%rax)
movl 0xfa8(%rax), %ecx
movl -0xc(%rbp), %edx
shll %edx
subl %edx, %ecx
movl %ecx, 0xfa8(%rax)
movl 0xfa8(%rax), %eax
movl %eax, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movl -0x10(%rbp), %eax
movl 0xfa8(%rcx), %ecx
addl -0xc(%rbp), %ecx
cmpl %ecx, %eax
jge 0x1e228
movq -0x18(%rbp), %rax
movl -0x10(%rbp), %ecx
addl $0x1, %ecx
movl %ecx, -0x10(%rbp)
movl -0x10(%rbp), %ecx
addl -0xc(%rbp), %ecx
movslq %ecx, %rcx
movl (%rax,%rcx,4), %edx
movslq -0x10(%rbp), %rcx
movslq (%rax,%rcx,4), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x1e1ee
popq %rbp
retq
nopw (%rax,%rax)
// File: navrajsaini[P]PL_Compiler_design_project/interp.cpp
// Function: Interpreter::call(int, int)
void Interpreter::call( int level, int address)
{
  int x;

  allocate(3);
  x = base_register;
  
  while ( level > 0)
  {
    x = store[x];
    --level;
  }
  store[stack_register - 2] = x;
  store[stack_register - 1] = base_register; 
  store[stack_register] = program_register + 3;
  
  base_register = stack_register - 2;
  program_register = address;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
movl $0x3, %esi
callq 0x1d9a0
movq -0x20(%rbp), %rax
movl 0xfac(%rax), %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, -0xc(%rbp)
jle 0x1e280
movq -0x20(%rbp), %rax
movslq -0x14(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x14(%rbp)
movl -0xc(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x1e261
movq -0x20(%rbp), %rax
movl -0x14(%rbp), %edx
movl 0xfa8(%rax), %ecx
subl $0x2, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl 0xfac(%rax), %edx
movl 0xfa8(%rax), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
movl 0xfb0(%rax), %edx
addl $0x3, %edx
movslq 0xfa8(%rax), %rcx
movl %edx, (%rax,%rcx,4)
movl 0xfa8(%rax), %ecx
subl $0x2, %ecx
movl %ecx, 0xfac(%rax)
movl -0x10(%rbp), %ecx
movl %ecx, 0xfb0(%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: navrajsaini[P]PL_Compiler_design_project/interp.cpp
// Function: Interpreter::arrow(int)
void Interpreter::arrow( int address)
{
  if ( store[stack_register] == 1 )
     program_register += 2;
  else
     program_register = address;
  --stack_register;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movslq 0xfa8(%rax), %rcx
cmpl $0x1, (%rax,%rcx,4)
jne 0x1e315
movq -0x18(%rbp), %rax
movl 0xfb0(%rax), %ecx
addl $0x2, %ecx
movl %ecx, 0xfb0(%rax)
jmp 0x1e322
movq -0x18(%rbp), %rax
movl -0xc(%rbp), %ecx
movl %ecx, 0xfb0(%rax)
movq -0x18(%rbp), %rax
movl 0xfa8(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0xfa8(%rax)
popq %rbp
retq
nopw (%rax,%rax)
// File: navrajsaini[P]PL_Compiler_design_project/interp.cpp
// Function: Interpreter::prog(int, int)
void Interpreter::prog( int variable_length, int address)
{
  base_register = stack_bottom;
//  cout << "base_register = " << stack_bottom << endl;
  stack_register = base_register;
//  cout << "stack_register = " << stack_register << endl;
  allocate( variable_length + 2);
  program_register = address;
//  cout << "program_register = " << program_register << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movl 0xfa4(%rdi), %eax
movl %eax, 0xfac(%rdi)
movl 0xfac(%rdi), %eax
movl %eax, 0xfa8(%rdi)
movl -0xc(%rbp), %esi
addl $0x2, %esi
callq 0x1d9a0
movq -0x18(%rbp), %rax
movl -0x10(%rbp), %ecx
movl %ecx, 0xfb0(%rax)
addq $0x20, %rsp
popq %rbp
retq
// File: navrajsaini[P]PL_Compiler_design_project/interp.cpp
// Function: Interpreter::memory_dump(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>) const
void Interpreter::memory_dump(string name) const
{
   const char *tempname = name.c_str();
   ofstream dump ( tempname, ios::out);
   
   if (!dump)
   {
     cerr << " couldn't open dump file " << endl;
     return;
   }

   int i = 0;
   
   while ( i < STORE_SIZE )
   {
     dump << store[i] << ' ';
     if ( ( i+1) % 20 == 0)
        dump << endl;
     i++;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x250, %rsp            # imm = 0x250
movq %rsi, -0x240(%rbp)
movq %rdi, %rax
movq -0x240(%rbp), %rdi
movq %rax, -0x8(%rbp)
movq %rdi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x238(%rbp)
callq 0x20c0
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rsi
leaq -0x218(%rbp), %rdi
movl $0x10, %edx
callq 0x21f0
movq -0x218(%rbp), %rax
movq -0x18(%rax), %rax
leaq -0x218(%rbp,%rax), %rdi
callq 0x20f0
movb %al, -0x22d(%rbp)
jmp 0x1e56d
movb -0x22d(%rbp), %al
testb $0x1, %al
jne 0x1e579
jmp 0x1e5dc
movq 0x8a70(%rip), %rdi      # 0x26ff0
leaq 0x16c1(%rip), %rsi      # 0x1fc48
callq 0x21b0
movq %rax, -0x248(%rbp)
jmp 0x1e595
movq -0x248(%rbp), %rdi
movq 0x8a15(%rip), %rsi      # 0x26fb8
callq 0x21d0
jmp 0x1e5aa
movl $0x1, -0x228(%rbp)
jmp 0x1e676
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x220(%rbp)
movl %eax, -0x224(%rbp)
leaq -0x218(%rbp), %rdi
callq 0x22d0
jmp 0x1e68b
movl $0x0, -0x22c(%rbp)
cmpl $0x3e8, -0x22c(%rbp)    # imm = 0x3E8
jge 0x1e66c
movq -0x238(%rbp), %rax
movslq -0x22c(%rbp), %rcx
movl (%rax,%rcx,4), %esi
leaq -0x218(%rbp), %rdi
callq 0x2320
movq %rax, -0x250(%rbp)
jmp 0x1e618
movq -0x250(%rbp), %rdi
movl $0x20, %esi
callq 0x2210
jmp 0x1e62b
movl -0x22c(%rbp), %eax
addl $0x1, %eax
movl $0x14, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0x1e658
movq 0x8970(%rip), %rsi      # 0x26fb8
leaq -0x218(%rbp), %rdi
callq 0x21d0
jmp 0x1e656
jmp 0x1e658
movl -0x22c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x22c(%rbp)
jmp 0x1e5e6
movl $0x0, -0x228(%rbp)
leaq -0x218(%rbp), %rdi
callq 0x22d0
addq $0x250, %rsp            # imm = 0x250
popq %rbp
retq
movq -0x220(%rbp), %rdi
callq 0x2340