LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3fde(%rip), %rcx      # 0x1384d
movl $0x2, %r8d
xorl %esi, %esi
callq 0x22b0
movq %rbx, %rdi
callq 0xc41a
leaq 0x5050(%rbx), %r14
leaq 0x3ae6(%rip), %rsi      # 0x13378
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xf8dc
leaq 0x3ad9(%rip), %rsi      # 0x1337e
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xf914
leaq 0x3ac9(%rip), %rsi      # 0x13381
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xf94c
movq %rbx, %rdi
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xc1be
leaq -0x70(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x3f64(%rip), %rsi      # 0x13850
leaq 0x3f61(%rip), %rdx      # 0x13854
leaq -0x80(%rbp), %r15
movq %r15, %rdi
callq 0x42dc
leaq 0x50c0(%rbx), %rdi
movq %r15, %rsi
callq 0xaa88
movq -0x80(%rbp), %rdi
jmp 0xf982
leaq -0x50(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x3f31(%rip), %rsi      # 0x13855
leaq 0x3f2f(%rip), %rdx      # 0x1385a
leaq -0x60(%rbp), %r15
movq %r15, %rdi
callq 0x42dc
leaq 0x50c0(%rbx), %rdi
movq %r15, %rsi
callq 0xaa88
movq -0x60(%rbp), %rdi
jmp 0xf982
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x3eff(%rip), %rsi      # 0x1385b
leaq 0x3eff(%rip), %rdx      # 0x13862
leaq -0x40(%rbp), %r15
movq %r15, %rdi
callq 0x42dc
leaq 0x50c0(%rbx), %rdi
movq %r15, %rsi
callq 0xaa88
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0xf98c
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 0xf9dd
movq %rax, %rbx
movq -0x60(%rbp), %rdi
jmp 0xf9dd
movq %rax, %rbx
movq -0x80(%rbp), %rdi
cmpq %r12, %rdi
je 0xf9e7
callq 0x21b0
movq %rbx, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O1/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::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 0x3e4a(%rip), %rcx      # 0x13859
movl $0x1, %r8d
xorl %esi, %esi
callq 0x22b0
movq %rbx, %rdi
callq 0xc41a
leaq 0x5050(%rbx), %r14
leaq 0x389a(%rip), %rsi      # 0x132cc
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
jne 0xfa69
leaq 0x5070(%rbx), %rdi
movq %r14, %rsi
callq 0x2100
movslq 0x2028(%rbx), %rsi
shlq $0x5, %rsi
addq %rbx, %rsi
movq %r14, %rdi
callq 0x2100
incl 0x2028(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::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 0x3d8f(%rip), %r15      # 0x13866
leaq 0x5050(%rdi), %r12
leaq 0x37e7(%rip), %r13      # 0x132cc
movq 0x50a0(%rbx), %rdx
movl $0x3, %r8d
movq %r14, %rdi
xorl %esi, %esi
movq %r15, %rcx
callq 0x22b0
movq %rbx, %rdi
callq 0xc41a
movq %r12, %rdi
movq %r13, %rsi
callq 0x2080
testl %eax, %eax
je 0xfb29
movq %r12, %rdi
leaq 0x37aa(%rip), %rsi      # 0x132ca
callq 0x2080
testl %eax, %eax
jne 0xfb3b
movq %rbx, %rdi
callq 0xfb4a
movq %rbx, %rdi
callq 0xfa6e
jmp 0xfae5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::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 0x3cf9(%rip), %rcx      # 0x1386a
movl $0x2, %r8d
xorl %esi, %esi
callq 0x22b0
movq %rbx, %rdi
callq 0xc41a
leaq 0x5050(%rbx), %r14
leaq 0x3736(%rip), %rsi      # 0x132ca
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xfbc7
leaq 0x3725(%rip), %rsi      # 0x132cc
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xfbff
movq %rbx, %rdi
addq $0x40, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xc1be
leaq -0x50(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x3c96(%rip), %rsi      # 0x1386d
leaq 0x3c92(%rip), %rdx      # 0x13870
leaq -0x60(%rbp), %r15
movq %r15, %rdi
callq 0x42dc
leaq 0x50c0(%rbx), %rdi
movq %r15, %rsi
callq 0xaa88
movq -0x60(%rbp), %rdi
jmp 0xfc35
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x3c62(%rip), %rsi      # 0x13871
leaq 0x3c63(%rip), %rdx      # 0x13879
leaq -0x40(%rbp), %r15
movq %r15, %rdi
callq 0x42dc
leaq 0x50c0(%rbx), %rdi
movq %r15, %rsi
callq 0xaa88
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0xfc3f
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 0xfc87
movq %rax, %rbx
movq -0x60(%rbp), %rdi
cmpq %r12, %rdi
je 0xfc91
callq 0x21b0
movq %rbx, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O1/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::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 0x3973(%rip), %r15      # 0x1387a
leaq 0x5050(%rdi), %r12
leaq 0x33b9(%rip), %r13      # 0x132ce
movq 0x50a0(%rbx), %rdx
movl $0x2, %r8d
movq %r14, %rdi
xorl %esi, %esi
movq %r15, %rcx
callq 0x22b0
movq %rbx, %rdi
callq 0xc41a
movq %r12, %rdi
movq %r13, %rsi
callq 0x2080
testl %eax, %eax
je 0xff6c
movq %r12, %rdi
leaq 0x3376(%rip), %rsi      # 0x132c6
callq 0x2080
testl %eax, %eax
je 0xff6c
movq %r12, %rdi
leaq 0x3361(%rip), %rsi      # 0x132c4
callq 0x2080
testl %eax, %eax
jne 0xff7e
movq %rbx, %rdi
callq 0xff8e
movq %rbx, %rdi
callq 0xfc9a
jmp 0xff15
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x38c8(%rip), %rcx      # 0x1387d
movl $0x2, %r8d
xorl %esi, %esi
callq 0x22b0
movq %rbx, %rdi
callq 0xc41a
leaq 0x5050(%rbx), %r14
leaq 0x32f6(%rip), %rsi      # 0x132ce
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0x10022
leaq 0x32db(%rip), %rsi      # 0x132c6
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0x1005a
leaq 0x32c6(%rip), %rsi      # 0x132c4
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0x10092
movq %rbx, %rdi
addq $0x60, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0xc1be
leaq -0x70(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x384e(%rip), %rsi      # 0x13880
leaq 0x384c(%rip), %rdx      # 0x13885
leaq -0x80(%rbp), %r15
movq %r15, %rdi
callq 0x42dc
leaq 0x50c0(%rbx), %rdi
movq %r15, %rsi
callq 0xaa88
movq -0x80(%rbp), %rdi
jmp 0x100c8
leaq -0x50(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x381c(%rip), %rsi      # 0x13886
leaq 0x381b(%rip), %rdx      # 0x1388c
leaq -0x60(%rbp), %r15
movq %r15, %rdi
callq 0x42dc
leaq 0x50c0(%rbx), %rdi
movq %r15, %rsi
callq 0xaa88
movq -0x60(%rbp), %rdi
jmp 0x100c8
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x37eb(%rip), %rsi      # 0x1388d
leaq 0x37ea(%rip), %rdx      # 0x13893
leaq -0x40(%rbp), %r15
movq %r15, %rdi
callq 0x42dc
leaq 0x50c0(%rbx), %rdi
movq %r15, %rsi
callq 0xaa88
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x100d2
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 0x10123
movq %rax, %rbx
movq -0x60(%rbp), %rdi
jmp 0x10123
movq %rax, %rbx
movq -0x80(%rbp), %rdi
cmpq %r12, %rdi
je 0x1012d
callq 0x21b0
movq %rbx, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O1/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::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 0x378a(%rip), %rcx      # 0x138de
movl $0x3, %r8d
xorl %esi, %esi
callq 0x22b0
movq %rbx, %rdi
callq 0xc41a
leaq 0x5050(%rbx), %rdi
leaq 0x34f2(%rip), %rsi      # 0x13669
callq 0x2080
testl %eax, %eax
je 0x10187
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
movl $0x1, 0x71b4(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x101a0
nop
// File: /workspace/github_cpp_makefile_star2_O1/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 0x3658(%rip), %rcx      # 0x1381a
movl $0x2, %r8d
xorl %esi, %esi
callq 0x22b0
movq %rbx, %rdi
callq 0xc41a
leaq 0x5050(%rbx), %r14
leaq 0x3484(%rip), %rsi      # 0x13669
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
jne 0x10261
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 0xf0ec
leaq 0x314d(%rip), %rsi      # 0x1337b
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
jne 0x10261
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_O1/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 0x365e(%rip), %rcx      # 0x138e9
movl $0x1, %r8d
xorl %esi, %esi
callq 0x22b0
movq %rbx, %rdi
callq 0xc41a
leaq 0x5050(%rbx), %r14
leaq 0x3012(%rip), %rsi      # 0x132c0
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0x102c6
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xc1be
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_O1/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 0x35ac(%rip), %rcx      # 0x138e2
xorl %r15d, %r15d
movl $0x2, %r8d
xorl %esi, %esi
callq 0x22b0
movq %rbx, %rdi
callq 0xc41a
leaq 0x5050(%rbx), %r14
leaq 0x3007(%rip), %rsi      # 0x13363
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0x1038d
leaq 0x2ffa(%rip), %rsi      # 0x13369
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0x103a5
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0xc1be
movl %r15d, 0x4de4(%rbx)
movslq 0x4d88(%rbx), %rax
movl %r15d, 0x4d60(%rbx,%rax,4)
jmp 0x103be
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_O1/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 0x10493
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 0x1048b
cmpl %esi, (%r8)
je 0x104c6
addq $0x1c, %r8
jmp 0x1047b
incq %rdx
cmpq %rax, %rdx
jne 0x1046e
leaq (%rax,%rax,2), %rax
movq 0x8(%rdi,%rax,8), %rdx
movq 0x10(%rdi,%rax,8), %rcx
cmpq %rcx, %rdx
setne %al
je 0x104c8
cmpl %esi, (%rdx)
je 0x104c8
addq $0x1c, %rdx
cmpq %rcx, %rdx
setne %al
je 0x104c8
leaq 0x1c(%rdx), %rdi
cmpl %esi, (%rdx)
movq %rdi, %rdx
jne 0x104b1
jmp 0x104c8
movb $0x1, %al
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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 0x10596
cmpb $0x0, (%r15)
je 0x1050f
xorl %eax, %eax
jmp 0x10586
cmpl $0x3, -0x4c(%rbp)
jne 0x10524
movq %rbx, %rdi
movl %r14d, %esi
callq 0x10458
testb %al, %al
jne 0x1050b
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 0x1057b
movups -0x50(%rbp), %xmm0
movups -0x44(%rbp), %xmm1
movups %xmm1, 0xc(%rsi)
movups %xmm0, (%rsi)
addq $0x1c, 0x8(%rdi)
jmp 0x10584
leaq -0x50(%rbp), %rdx
callq 0x10aae
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_O1/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 0x10616
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
movl -0x18(%rdi), %r9d
cmpl %edx, %r9d
je 0x105e9
addq $0x1c, %rdi
decq %r8
jne 0x105d5
jmp 0x10615
movb $0x1, %dl
movb %dl, (%rcx)
movb %dl, (%rsi)
movl %r9d, (%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_O1/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), %rcx
movq 0x8(%rdi,%rcx,8), %rax
movq 0x10(%rdi,%rcx,8), %rdx
cmpq %rdx, %rax
je 0x10674
leaq (%rdi,%rcx,8), %rcx
addq $0x8, %rcx
movq 0x8(%rcx), %rsi
movq %rsi, %r8
subq %rdx, %r8
addq %r8, %rax
cmpq %rax, %rsi
je 0x10674
movq %rax, 0x8(%rcx)
movl 0xf8(%rdi), %eax
testl %eax, %eax
js 0x10686
decl %eax
movl %eax, 0xf8(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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), %ecx
addq $0x8, %rdi
movq %rcx, %rdx
leaq (%rdx,%rdx,2), %r8
movq (%rdi,%r8,8), %r10
movq 0x8(%rdi,%r8,8), %r9
cmpq %r9, %r10
sete %r8b
je 0x109a7
cmpl %esi, (%r10)
je 0x109a3
addq $0x1c, %r10
cmpq %r9, %r10
sete %r8b
je 0x109a7
leaq 0x1c(%r10), %r11
cmpl %esi, (%r10)
movq %r11, %r10
jne 0x1098e
movl %ecx, %eax
subl %edx, %eax
testb %r8b, %r8b
je 0x109b8
leaq -0x1(%rdx), %r8
testq %rdx, %rdx
movq %r8, %rdx
jg 0x1096f
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/navrajsaini[P]PL_Compiler_design_project/BlockTable.cpp
// Function: BlockTable::find_all_level(int)
TableEntry BlockTable::find_all_level (int index)
{
   TableEntry a;

   for (auto it = table[blockLevel].begin(); it != table[blockLevel].end(); ++it)
   //looks through the current block level
   {
      if (it -> idindex == index)
      //if the index is found returns the table entry
      //and set inScope to true to make sure the variable is declared
      {
	       a.idindex = it -> idindex;
	       a.kind = it -> kind;
	       a.type = it -> type;
	       a.size = it -> size;
	       a.value = it -> value;
	       a.disp = it -> disp;
	       a.procLabel = it -> procLabel;
	       inScope = true;
	       return a;
      }
   }
   inScope = false;
   //if the variable is not found in the current block level
   //search all the block levels up to the current one
   for (int i = blockLevel; i >= 0; i--)
   {
      for (auto it = table[i].begin(); it != table[i].end(); ++it)
      {
    	 if (it -> idindex == index)
    	 {
    	    a.idindex = it -> idindex;
    	    a.kind = it -> kind;
    	    a.type = it -> type;
    	    a.size = it -> size;
    	    a.value = it -> value;
    	    a.disp = it -> disp;
    	    a.procLabel = it -> procLabel;
    	    inScope = true;
    	    return a;
    	 }
      }
   }
   inScope = false;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, %rax
movslq 0xf8(%rsi), %rcx
leaq (%rcx,%rcx,2), %r8
movq 0x8(%rsi,%r8,8), %rdi
movq 0x10(%rsi,%r8,8), %r9
cmpq %r9, %rdi
sete %r8b
je 0x10a49
movl (%rdi), %r10d
cmpl %edx, %r10d
je 0x10a10
addq $0x1c, %rdi
cmpq %r9, %rdi
sete %r8b
je 0x10a49
movl (%rdi), %r10d
addq $0x1c, %rdi
cmpl %edx, %r10d
jne 0x109f7
addq $-0x1c, %rdi
movl %r10d, (%rax)
movl 0x4(%rdi), %r9d
movl %r9d, 0x4(%rax)
movl 0x8(%rdi), %r9d
movl %r9d, 0x8(%rax)
movl 0xc(%rdi), %r9d
movl %r9d, 0xc(%rax)
movl 0x10(%rdi), %r9d
movl %r9d, 0x10(%rax)
movl 0x14(%rdi), %r9d
movl %r9d, 0x14(%rax)
movl 0x18(%rdi), %edi
movl %edi, 0x18(%rax)
movb $0x1, (%rsi)
testb %r8b, %r8b
je 0x10aac
movb $0x0, (%rsi)
testl %ecx, %ecx
js 0x10aac
leaq 0x8(%rsi), %r8
leaq (%rcx,%rcx,2), %r9
movq (%r8,%r9,8), %rdi
movq 0x8(%r8,%r9,8), %r9
cmpq %r9, %rdi
je 0x10a74
movl (%rdi), %r10d
cmpl %edx, %r10d
je 0x10a82
addq $0x1c, %rdi
jmp 0x10a61
leaq -0x1(%rcx), %rdi
testq %rcx, %rcx
movq %rdi, %rcx
jg 0x10a54
jmp 0x10aac
movl %r10d, (%rax)
movl 0x4(%rdi), %ecx
movl %ecx, 0x4(%rax)
movl 0x8(%rdi), %ecx
movl %ecx, 0x8(%rax)
movl 0xc(%rdi), %ecx
movl %ecx, 0xc(%rax)
movl 0x10(%rdi), %ecx
movl %ecx, 0x10(%rax)
movl 0x14(%rdi), %ecx
movl %ecx, 0x14(%rax)
movl 0x18(%rdi), %ecx
movl %ecx, 0x18(%rax)
movb $0x1, (%rsi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rsi, %r15
movq %rdi, %rbx
movb %dl, 0xfb5(%rdi)
movq 0x72f2(%rip), %r14      # 0x18fc8
leaq 0x1d1b(%rip), %rsi      # 0x139f8
movl $0xb, %edx
movq %r14, %rdi
callq 0x2210
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2140
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq -0x40(%rbp), %r15
movq %r15, %rdi
callq 0x4242
movq %rbx, %rdi
movq %r15, %rsi
callq 0x11db2
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x11d49
callq 0x21b0
leaq 0x1cb4(%rip), %rsi      # 0x13a04
movl $0xc, %edx
movq %r14, %rdi
callq 0x2210
movq (%r14), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2140
movq %rbx, %rdi
callq 0x11f6e
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x11daa
callq 0x21b0
movq %rbx, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O1/navrajsaini[P]PL_Compiler_design_project/interp.cpp
// Function: Interpreter::load_program(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Interpreter::load_program( string name)
{
  int x = 0;
  int word;
  const char* tempname = name.c_str(); 
  ifstream program(tempname, ios::in);
  
  if (!program)
  {
    cerr << " Could not open program file" << endl;
    return;
  }

// read program into memory

  while (!program.eof())
  {
    program >> word;
//    cout << " Read word " << word << endl;
    store[x] = word;
    if ( word == -1) break;
    ++x;
//    cout << "x is " << x << endl;
    
    if ( x >= STORE_SIZE)
    {
      cerr << "program exceeded" << x << " words " << endl;
      cerr << "Not enough memory to load program " << endl;
      return;
     }
   }
  
   stack_bottom = x;

 //  cout << "stack_bottom = " << x << endl;
   
   // clear the rest of memory

   for (int i = stack_bottom; i <= STORE_SIZE; i++)
      store[i] = -1;
   program.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
movq %rdi, %rbx
movq (%rsi), %rsi
leaq -0x238(%rbp), %r14
movq %r14, %rdi
movl $0x8, %edx
callq 0x2340
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x218(%rbp,%rax)
je 0x11e3c
movl $0x1c, %edx
leaq 0x1c58(%rip), %rsi      # 0x13a55
movq 0x71ec(%rip), %rbx      # 0x18ff0
movq %rbx, %rdi
callq 0x2210
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq 0x71c6(%rip), %rdi      # 0x18ff0
callq 0x2030
movq %rax, %rdi
callq 0x2140
jmp 0x11f36
movl $0xfa4, %r14d           # imm = 0xFA4
xorl %r13d, %r13d
leaq -0x238(%rbp), %r15
leaq -0x2c(%rbp), %r12
movq -0x238(%rbp), %rax
movq -0x18(%rax), %rax
testb $0x2, -0x218(%rbp,%rax)
jne 0x11f09
movq %r15, %rdi
movq %r12, %rsi
callq 0x2120
movl -0x2c(%rbp), %eax
movl %eax, (%rbx,%r13,4)
cmpl $-0x1, %eax
je 0x11f09
incq %r13
addq $-0x4, %r14
cmpq $0x4, %r14
jne 0x11e50
movq 0x7158(%rip), %rdi      # 0x18ff0
leaq 0x1bd3(%rip), %rsi      # 0x13a72
movl $0x10, %edx
callq 0x2210
movq 0x7140(%rip), %rdi      # 0x18ff0
movl $0x3e8, %esi            # imm = 0x3E8
callq 0x22f0
movq %rax, %rbx
leaq 0x1bbf(%rip), %rsi      # 0x13a83
movl $0x7, %edx
movq %rax, %rdi
callq 0x2210
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2140
movl $0x22, %edx
leaq 0x1b87(%rip), %rsi      # 0x13a8b
jmp 0x11dfd
movl %r13d, 0xfa4(%rbx)
cmpq $0x3e8, %r13            # imm = 0x3E8
ja 0x11f2a
leaq (%rbx,%r13,4), %rdi
movl $0xff, %esi
movq %r14, %rdx
callq 0x2110
leaq -0x238(%rbp), %rdi
callq 0x2050
leaq -0x238(%rbp), %rdi
callq 0x2060
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x11f56
movq %rax, %rbx
leaq -0x238(%rbp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
cmpl $-0x1, %edx
je 0x124c0
movl %edx, %r15d
movq 0x6b68(%rip), %r12      # 0x18ff0
leaq 0x1183(%rip), %rsi      # 0x13612
movl $0x5, %edx
movq %r12, %rdi
callq 0x2210
movq %r12, %rdi
movl %r15d, %esi
callq 0x22f0
movq %rax, %r15
leaq 0x118c(%rip), %rsi      # 0x1363d
movl $0x3, %edx
movq %rax, %rdi
callq 0x2210
jmp 0x124c7
movq 0x6b29(%rip), %r15      # 0x18ff0
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r15, %rdi
callq 0x2210
movq %rax, %r14
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2140
movb $0x0, 0xfb4(%rbx)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %r14d
movl %esi, %r15d
movq %rdi, %rbx
movl $0x1, %esi
callq 0x12510
movl 0xfac(%rbx), %eax
testl %r15d, %r15d
jle 0x125d1
incl %r15d
cltq
movl (%rbx,%rax,4), %eax
decl %r15d
cmpl $0x1, %r15d
jg 0x125c3
addl %r14d, %eax
movslq 0xfa8(%rbx), %rcx
movl %eax, (%rbx,%rcx,4)
addl $0x3, 0xfb0(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movl %edx, %r14d
movq %rdi, %rbx
movslq 0xfa8(%rdi), %rax
movl (%rdi,%rax,4), %ecx
leal -0x1(%rax), %edx
movl %edx, 0xfa8(%rdi)
testl %ecx, %ecx
setg %dl
cmpl %esi, %ecx
setle %sil
testb %sil, %dl
jne 0x12669
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
leaq 0x13e9(%rip), %rsi      # 0x13a21
leaq 0x13ee(%rip), %rdx      # 0x13a2d
leaq -0x40(%rbp), %r15
movq %r15, %rdi
callq 0x42dc
movq %rbx, %rdi
movq %r15, %rsi
movl %r14d, %edx
callq 0x12468
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x12675
callq 0x21b0
jmp 0x12675
movl -0x4(%rbx,%rax,4), %edx
addl %edx, %ecx
decl %ecx
movl %ecx, -0x4(%rbx,%rax,4)
addl $0x3, 0xfb0(%rbx)
addq $0x20, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0x1269a
callq 0x21b0
movq %rbx, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O1/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
incl 0xfb0(%rdi)
movslq 0xfa8(%rdi), %rax
leaq -0x1(%rax), %rcx
movl %ecx, 0xfa8(%rdi)
cmpl $0x1, -0x4(%rdi,%rax,4)
jne 0x1289b
movl (%rdi,%rax,4), %ecx
movl %ecx, -0x4(%rdi,%rax,4)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
incl 0xfb0(%rdi)
movslq 0xfa8(%rdi), %rax
leaq -0x1(%rax), %rcx
movl %ecx, 0xfa8(%rdi)
cmpl $0x0, -0x4(%rdi,%rax,4)
jne 0x128c7
movl (%rdi,%rax,4), %ecx
movl %ecx, -0x4(%rdi,%rax,4)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
addl $0x2, 0xfb0(%rdi)
movl 0xfa8(%rdi), %eax
subl %esi, %eax
movl %eax, 0xfa8(%rdi)
testl %esi, %esi
jle 0x1294e
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq %eax, %r14
movq 0x66da(%rip), %r12      # 0x18fd8
movslq %esi, %r13
leaq 0x1(%r14), %r15
movl $0x7, %edx
movq 0x66b7(%rip), %rdi      # 0x18fc8
leaq 0x1116(%rip), %rsi      # 0x13a2e
callq 0x2210
movslq 0x4(%rbx,%r14,4), %rax
leaq (%rbx,%rax,4), %rsi
movq %r12, %rdi
callq 0x2120
movslq 0xfa8(%rbx), %rax
addq %r13, %rax
movq %r15, %r14
cmpq %rax, %r15
jl 0x12901
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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:
addl $0x2, 0xfb0(%rdi)
movl 0xfa8(%rdi), %eax
subl %esi, %eax
movl %eax, 0xfa8(%rdi)
testl %esi, %esi
jle 0x129fb
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq %eax, %r12
movq 0x6640(%rip), %r14      # 0x18fc8
movslq %esi, %r13
leaq 0x1(%r12), %r15
movl $0xa, %edx
movq %r14, %rdi
leaq 0x1097(%rip), %rsi      # 0x13a36
callq 0x2210
movl 0x4(%rbx,%r12,4), %esi
movq %r14, %rdi
callq 0x22f0
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %r12, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2140
movslq 0xfa8(%rbx), %rax
addq %r13, %rax
movq %r15, %r12
cmpq %rax, %r15
jl 0x1298b
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/navrajsaini[P]PL_Compiler_design_project/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
addl $0x2, 0xfb0(%rdi)
movl 0xfa8(%rdi), %eax
subl %esi, %eax
subl %esi, %eax
movl %eax, 0xfa8(%rdi)
testl %esi, %esi
jle 0x12a4d
movslq %eax, %rdx
movl %esi, %eax
leaq (%rdi,%rax,4), %rax
addq $0x4, %rax
movslq %esi, %rcx
movl (%rax,%rdx,4), %esi
movslq 0x4(%rdi,%rdx,4), %r8
leaq 0x1(%rdx), %r9
movl %esi, (%rdi,%r8,4)
movslq 0xfa8(%rdi), %rsi
addq %rcx, %rsi
movq %r9, %rdx
cmpq %rsi, %r9
jl 0x12a2b
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebx
movl %esi, %r15d
movq %rdi, %r14
movl $0x3, %esi
callq 0x12510
movl 0xfac(%r14), %eax
testl %r15d, %r15d
jle 0x12a8a
incl %r15d
cltq
movl (%r14,%rax,4), %eax
decl %r15d
cmpl $0x1, %r15d
jg 0x12a7b
movslq 0xfa8(%r14), %rcx
movl %eax, -0x8(%r14,%rcx,4)
movl 0xfac(%r14), %eax
movslq 0xfa8(%r14), %rcx
movl %eax, -0x4(%r14,%rcx,4)
movl 0xfb0(%r14), %eax
addl $0x3, %eax
movslq 0xfa8(%r14), %rcx
movl %eax, (%r14,%rcx,4)
movl 0xfa8(%r14), %eax
addl $-0x2, %eax
movl %eax, 0xfac(%r14)
movl %ebx, 0xfb0(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rdi, %r14
movl 0xfa4(%rdi), %eax
movl %eax, 0xfac(%rdi)
movl %eax, 0xfa8(%rdi)
addl $0x2, %esi
callq 0x12510
movl %ebx, 0xfb0(%r14)
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x208, %rsp            # imm = 0x208
movq %rdi, %rbx
movq (%rsi), %rsi
leaq -0x230(%rbp), %r14
movq %r14, %rdi
movl $0x10, %edx
callq 0x21f0
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, -0x210(%rbp,%rax)
je 0x12ca4
movq 0x6390(%rip), %rbx      # 0x18ff0
leaq 0xe8d(%rip), %rsi       # 0x13af4
movl $0x19, %edx
movq %rbx, %rdi
callq 0x2210
movq (%rbx), %rax
addq -0x18(%rax), %rbx
movq %rbx, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq 0x635e(%rip), %rdi      # 0x18ff0
callq 0x2030
movq %rax, %rdi
callq 0x2140
jmp 0x12d2e
movl $0x1, %r12d
xorl %r13d, %r13d
leaq -0x29(%rbp), %r15
movl (%rbx,%r13,4), %esi
movq %r14, %rdi
callq 0x22f0
movb $0x20, -0x29(%rbp)
movl $0x1, %edx
movq %rax, %rdi
movq %r15, %rsi
callq 0x2210
movl %r12d, %eax
movl $0xcccccccd, %ecx       # imm = 0xCCCCCCCD
imulq %rcx, %rax
shrq $0x24, %rax
leal (%rax,%rax,4), %eax
leal -0x4(,%rax,4), %eax
orq $0x3, %rax
cmpl %r13d, %eax
jne 0x12d1f
movq -0x230(%rbp), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %r14, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2140
incq %r13
incl %r12d
cmpq $0x3e8, %r13            # imm = 0x3E8
jne 0x12cb1
movq 0x628b(%rip), %rax      # 0x18fc0
movq (%rax), %rcx
movq 0x18(%rax), %rax
leaq -0x228(%rbp), %rdi
movq %rcx, -0x8(%rdi)
movq -0x18(%rcx), %rcx
movq %rax, -0x230(%rbp,%rcx)
callq 0x2180
leaq -0x138(%rbp), %rdi
callq 0x2090
addq $0x208, %rsp            # imm = 0x208
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x12d78
movq %rax, %rbx
leaq -0x230(%rbp), %rdi
callq 0x2290
movq %rbx, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O1/nmmmnu[P]HM3/hm3/hashindex/hashindexbuilder_impl.h
// Function: hm3::hashindex::HashIndexBuilder::printStats_(unsigned long, unsigned long)
void HashIndexBuilder::printStats_(size_t const size, size_t const collisions){
	constexpr const char *MASKZ = "%-16s : %12zu\n";
	constexpr const char *MASKF = "%-16s : %15.2f %%\n";

	double const percent = 100.0 * (double) collisions / (double) size;

	printf(MASKZ, "Total",			size			);
	printf(MASKZ, "Total Present",		size - collisions	);
	printf(MASKF, "Percent Present",	100 - percent		);
	printf(MASKZ, "Collisions",		collisions		);
	printf(MASKF, "Percent Missing",	percent			);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x10, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %xmm0
movq 0x2b74(%rip), %xmm1     # 0x5010
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
movapd 0x2b78(%rip), %xmm2     # 0x5020
subpd %xmm2, %xmm0
movapd %xmm0, %xmm3
unpckhpd %xmm0, %xmm3            # xmm3 = xmm3[1],xmm0[1]
addsd %xmm0, %xmm3
mulsd 0x2b70(%rip), %xmm3     # 0x5030
movq %rdi, %xmm0
punpckldq %xmm1, %xmm0    # xmm0 = xmm0[0],xmm1[0],xmm0[1],xmm1[1]
subpd %xmm2, %xmm0
movapd %xmm0, %xmm1
unpckhpd %xmm0, %xmm1            # xmm1 = xmm1[1],xmm0[1]
addsd %xmm0, %xmm1
divsd %xmm1, %xmm3
movapd %xmm3, (%rsp)
leaq 0x2b4f(%rip), %r15      # 0x5038
leaq 0x2b6a(%rip), %rsi      # 0x505a
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x2030
subq %rbx, %r14
leaq 0x2b59(%rip), %rsi      # 0x5060
movq %r15, %rdi
movq %r14, %rdx
xorl %eax, %eax
callq 0x2030
movsd 0x2b14(%rip), %xmm0     # 0x5030
subsd (%rsp), %xmm0
leaq 0x2b1f(%rip), %r14      # 0x5047
leaq 0x2b3f(%rip), %rsi      # 0x506e
movq %r14, %rdi
movb $0x1, %al
callq 0x2030
leaq 0x2b3e(%rip), %rsi      # 0x507e
movq %r15, %rdi
movq %rbx, %rdx
xorl %eax, %eax
callq 0x2030
leaq 0x2b35(%rip), %rsi      # 0x5089
movq %r14, %rdi
movaps (%rsp), %xmm0
movb $0x1, %al
addq $0x10, %rsp
popq %rbx
popq %r14
popq %r15
jmp 0x2030
// File: /workspace/github_cpp_makefile_star2_O1/nmmmnu[P]HM3/hm3/hashindex/hashindexbuilder_impl.h
// Function: bool hm3::hashindex::HashIndexBuilder::createFromList<hm3::DiskTable>(StringRef const&, hm3::DiskTable const&, bool) const
bool HashIndexBuilder::createFromList(const StringRef &filename2, const LIST &list, bool const stats) const{
	size_t const hashtableSize = list.getCount() * growFactor_;
	size_t const sizeBin       = hashtableSize * sizeof(uint64_t);

	const std::string filename = filenameIndx(filename2);

	// create file

	if ( ! MMAPFile::createFile(filename, sizeBin) ){
		return false;
	}

	// open file

	MMAPFile mmap{ MADV_RANDOM };
	if ( ! mmap.openRW(filename) ){
		return false;
	}

	uint64_t *hashtable = (uint64_t *) mmap.mem();

	// memset is not good, because it needs size to be int
	log__("Set hashtable to zeroes.");
	std::fill(hashtable, hashtable + hashtableSize, htobe64(BUCKET_EMPTY));

	// process

	size_t const collisions = createFromList_(hashtable, hashtableSize, list);

	if (stats)
		printStats_(list.getCount(), collisions);

	return true;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %ecx, 0x2c(%rsp)
movq %rdx, %rbx
movq %rdi, %r15
movq 0x8(%rdx), %r14
imulq (%rdi), %r14
movups (%rsi), %xmm0
movaps %xmm0, 0x30(%rsp)
movq $0x5, 0x40(%rsp)
leaq 0x28ce(%rip), %rax      # 0x515c
movq %rax, 0x48(%rsp)
leaq 0x18(%rsp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
xorl %esi, %esi
xorl %eax, %eax
addq 0x30(%rsp,%rax), %rsi
addq $0x10, %rax
cmpq $0x20, %rax
jne 0x28ab
leaq 0x8(%rsp), %rdi
callq 0x2220
leaq (,%r14,8), %r13
movl $0x8, %ebp
leaq 0x8(%rsp), %r12
movq 0x28(%rsp,%rbp), %rdx
movq 0x30(%rsp,%rbp), %rsi
movq %r12, %rdi
callq 0x2050
addq $0x10, %rbp
cmpq $0x28, %rbp
jne 0x28d6
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
leaq 0x30(%rsp), %rdi
movq %rcx, (%rdi)
movq %rax, 0x8(%rdi)
movq %r13, %rsi
callq 0x45c8
testb %al, %al
je 0x29a2
xorps %xmm0, %xmm0
leaq 0x30(%rsp), %rdi
movaps %xmm0, (%rdi)
movl $0x1, 0x14(%rdi)
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rcx
leaq 0x58(%rsp), %rsi
movq %rcx, (%rsi)
movq %rax, 0x8(%rsi)
callq 0x4592
movl %eax, %r12d
testb %al, %al
je 0x2996
movq 0x30(%rsp), %rbp
leaq 0x27eb(%rip), %rdi      # 0x5143
callq 0x27dc
testq %r14, %r14
je 0x2972
movq %rbp, %rdi
movl $0xff, %esi
movq %r13, %rdx
callq 0x20c0
movq %r15, %rdi
movq %rbp, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x2a66
cmpb $0x0, 0x2c(%rsp)
je 0x2996
movq 0x8(%rbx), %rdi
movq %rax, %rsi
callq 0x2480
leaq 0x30(%rsp), %rdi
callq 0x45a2
jmp 0x29a5
xorl %r12d, %r12d
leaq 0x18(%rsp), %rax
movq 0x8(%rsp), %rdi
cmpq %rax, %rdi
je 0x29c1
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2180
movl %r12d, %eax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x29d9
jmp 0x29d9
jmp 0x29e8
movq %rax, %rbx
leaq 0x30(%rsp), %rdi
callq 0x45a2
jmp 0x29f7
movq %rax, %rdi
callq 0x2a5a
jmp 0x29f4
jmp 0x29f4
movq %rax, %rbx
movq 0x8(%rsp), %rdi
leaq 0x18(%rsp), %rax
cmpq %rax, %rdi
je 0x2a13
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2180
movq %rbx, %rdi
callq 0x2260
nop
// File: /workspace/github_cpp_makefile_star2_O1/nmmmnu[P]HM3/hm3/hashindex/hashindexbuilder_impl.h
// Function: unsigned long hm3::hashindex::HashIndexBuilder::createFromList_<hm3::DiskTable>(unsigned long*, unsigned long, hm3::DiskTable const&) const
size_t HashIndexBuilder::createFromList_(uint64_t *hashtable, size_t const hashtableSize, const LIST &list) const{
	uint64_t const BE_BUCKET_EMPTY		= htobe64(BUCKET_EMPTY		);
	uint64_t const BE_BUCKET_COLLISION	= htobe64(BUCKET_COLLISION	);

	size_t collisions = 0;

	log__("Creating hashtable.");
	DiskTable::size_type index = 0;
	for(const auto &p : list){
		auto const bucket = bucketForKey_(p.getKey(), hashtableSize);

		auto const htb = hashtable[bucket];

		if (htb == BE_BUCKET_EMPTY){
			hashtable[bucket] = htobe64(index);

		}else{
			++collisions;

			if (htb != BE_BUCKET_COLLISION){
				hashtable[bucket] = BE_BUCKET_COLLISION;
				++collisions;
			}
		}


		++index;
	}

	return collisions;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movq %rcx, %r15
movq %rdx, %rbx
movq %rsi, %r14
leaq 0x26e0(%rip), %rdi      # 0x5164
callq 0x27dc
movzbl 0x18(%r15), %ecx
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
xorl %edx, %edx
callq 0x4262
movq 0x8(%r15), %rdx
leaq 0x38(%rsp), %rdi
movq %r15, %rsi
xorl %ecx, %ecx
callq 0x4262
movq 0x8(%rsp), %rax
cmpq 0x38(%rsp), %rax
jne 0x2ad0
movq 0x40(%rsp), %rax
cmpq %rax, 0x10(%rsp)
jne 0x2ad0
xorl %r15d, %r15d
jmp 0x2b7b
movabsq $-0x100000000000001, %r13 # imm = 0xFEFFFFFFFFFFFFFF
xorl %r15d, %r15d
leaq 0x8(%rsp), %r12
xorl %ebp, %ebp
movq %r12, %rdi
callq 0x427c
movq %rax, %rdi
callq 0x2c7c
movb (%rdx), %cl
testb %cl, %cl
je 0x2b1e
incq %rdx
movl $0x1505, %eax           # imm = 0x1505
movq %rax, %rsi
shlq $0x5, %rsi
addq %rax, %rsi
movsbq %cl, %rax
xorq %rsi, %rax
movb (%rdx), %cl
incq %rdx
testb %cl, %cl
jne 0x2b02
jmp 0x2b23
movl $0x1505, %eax           # imm = 0x1505
xorl %edx, %edx
divq %rbx
movq (%r14,%rdx,8), %rax
cmpq $-0x1, %rax
je 0x2b3c
cmpq %r13, %rax
jne 0x2b48
incq %r15
jmp 0x2b50
movq %rbp, %rax
bswapq %rax
movq %rax, (%r14,%rdx,8)
jmp 0x2b50
movq %r13, (%r14,%rdx,8)
addq $0x2, %r15
incq %rbp
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
incq %rax
movq %rax, 0x10(%rsp)
cmpq 0x38(%rsp), %rcx
jne 0x2ae4
cmpq 0x40(%rsp), %rax
jne 0x2ae4
leaq 0x60(%rsp), %rdi
callq 0x2bc8
leaq 0x30(%rsp), %rdi
callq 0x2bc8
movq %r15, %rax
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
jmp 0x2bb3
movq %rax, %rbx
leaq 0x60(%rsp), %rdi
callq 0x2bc8
leaq 0x30(%rsp), %rdi
callq 0x2bc8
movq %rbx, %rdi
callq 0x2260
nopl (%rax)