LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::ReadStat()
void Parse::ReadStat()//read statement
{where="RS";check();
   if(LHS=="read")
   {
      
      match();
      VarAcList();
      
      gen.emit2("READ", tempSizeRead);
      tempSizeRead = 0;
      
   }else
   {

   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
addq $0x5098, %rdi           # imm = 0x5098
leaq 0x47c1(%rip), %rsi      # 0xf7b5
callq 0x2310
movq %rbx, %rdi
callq 0x97e2
leaq 0x5050(%rbx), %rdi
leaq 0x4060(%rip), %rsi      # 0xf06f
callq 0x7926
testb %al, %al
je 0xb064
movq %rbx, %rdi
callq 0x9522
movq %rbx, %rdi
callq 0xb620
leaq 0x4789(%rip), %rsi      # 0xf7b8
leaq -0x38(%rbp), %r14
leaq -0x11(%rbp), %rdx
movq %r14, %rdi
callq 0x20a0
leaq 0x50c0(%rbx), %rdi
movl 0x71f0(%rbx), %edx
movq %r14, %rsi
callq 0x85c6
leaq -0x38(%rbp), %rdi
callq 0x20d0
andl $0x0, 0x71f0(%rbx)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x22e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::WriteStat()
void Parse::WriteStat()//write statement
{where="WS";check();
   if(LHS=="write")
   {
      match();
      ExpList();
      gen.emit2("WRITE", tempSizeWrite);
      tempSizeWrite = 0;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
addq $0x5098, %rdi           # imm = 0x5098
leaq 0x46f6(%rip), %rsi      # 0xf7c6
callq 0x2310
movq %rbx, %rdi
callq 0x97e2
leaq 0x5050(%rbx), %rdi
leaq 0x3fa1(%rip), %rsi      # 0xf08c
callq 0x7926
testb %al, %al
je 0xb140
movq %rbx, %rdi
callq 0x9522
movq %rbx, %rdi
callq 0xb8c4
leaq 0x46be(%rip), %rsi      # 0xf7c9
leaq -0x38(%rbp), %r14
leaq -0x11(%rbp), %rdx
movq %r14, %rdi
callq 0x20a0
leaq 0x50c0(%rbx), %rdi
movl 0x71f4(%rbx), %edx
movq %r14, %rsi
callq 0x85c6
leaq -0x38(%rbp), %rdi
callq 0x20d0
andl $0x0, 0x71f4(%rbx)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x22e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::AsnStat()
void Parse::AsnStat()//assignment statement
{where="AS";check();
 
   VarAcList();
   
   if(LHS==":=")
   {
      match();
      ExpList();
   }else
      errorReport();
   gen.emit2("ASSIGN", tempSizeAsn);
   
   tempSizeAsn = 0;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
addq $0x5098, %rdi           # imm = 0x5098
leaq 0x465c(%rip), %rsi      # 0xf7d6
callq 0x2310
movq %rbx, %rdi
callq 0x97e2
movq %rbx, %rdi
callq 0xb620
leaq 0x5050(%rbx), %rdi
leaq 0x41d7(%rip), %rsi      # 0xf374
callq 0x7926
movq %rbx, %rdi
testb %al, %al
je 0xb1b8
callq 0x9522
movq %rbx, %rdi
callq 0xb8c4
jmp 0xb1bd
callq 0x9672
leaq 0x4615(%rip), %rsi      # 0xf7d9
leaq -0x38(%rbp), %r14
leaq -0x11(%rbp), %rdx
movq %r14, %rdi
callq 0x20a0
leaq 0x50c0(%rbx), %rdi
movl 0x71f8(%rbx), %edx
movq %r14, %rsi
callq 0x85c6
leaq -0x38(%rbp), %rdi
callq 0x20d0
andl $0x0, 0x71f8(%rbx)
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O2/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::ProcStat()
void Parse::ProcStat()//procedure statement
{where="PS";check();
   if(LHS=="call")
   {
      match();      
      ProcName();
            if(!bTable.search(index))
	 scopeError("Procedure Not Defined in ProcStat");

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

      
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x68, %rsp
movq %rdi, %rbx
addq $0x5098, %rdi           # imm = 0x5098
leaq 0x45ac(%rip), %rsi      # 0xf7e0
callq 0x2310
movq %rbx, %rdi
callq 0x97e2
leaq 0x5050(%rbx), %rdi
leaq 0x3dce(%rip), %rsi      # 0xf01d
callq 0x7926
testb %al, %al
je 0xb320
movq %rbx, %rdi
callq 0x9522
movq %rbx, %rdi
callq 0xae02
leaq 0x4c38(%rbx), %r14
movl 0x4ddc(%rbx), %esi
movq %r14, %rdi
callq 0xc7d2
testb %al, %al
jne 0xb2ae
leaq 0x4557(%rip), %rsi      # 0xf7e3
leaq -0x58(%rbp), %rdi
leaq -0x74(%rbp), %rdx
callq 0x20a0
leaq -0x58(%rbp), %rsi
movq %rbx, %rdi
callq 0x9890
leaq -0x58(%rbp), %rdi
callq 0x20d0
movl 0x4ddc(%rbx), %edx
leaq -0x74(%rbp), %r15
movq %r15, %rdi
movq %r14, %rsi
callq 0xcb82
movups (%r15), %xmm0
movups 0xc(%r15), %xmm1
movups %xmm1, 0x4e1c(%rbx)
movups %xmm0, 0x4e10(%rbx)
leaq 0x4524(%rip), %rsi      # 0xf805
leaq -0x38(%rbp), %rdi
leaq -0x74(%rbp), %rdx
callq 0x20a0
movl 0x4ddc(%rbx), %esi
movq %r14, %rdi
callq 0xcb3c
movl 0x4e28(%rbx), %ecx
addq $0x50c0, %rbx           # imm = 0x50C0
leaq -0x38(%rbp), %rsi
movq %rbx, %rdi
movl %eax, %edx
callq 0x8630
leaq -0x38(%rbp), %rdi
callq 0x20d0
addq $0x68, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
jmp 0xb342
jmp 0xb336
movq %rax, %rbx
jmp 0xb347
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x22e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::IfStat()
void Parse::IfStat()//if statements
{where="IS";check();

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rdi, %r14
addq $0x5098, %rdi           # imm = 0x5098
leaq 0x449a(%rip), %rsi      # 0xf80a
callq 0x2310
movq %r14, %rdi
callq 0x97e2
movq %r14, %rdi
callq 0x9522
movl 0x71b0(%r14), %ebx
leal 0x1(%rbx), %r12d
addl $0x2, %ebx
movl %ebx, 0x71b0(%r14)
leaq -0x28(%rbp), %rsi
movl %r12d, (%rsi)
movq %r14, %rdi
movl %ebx, %edx
callq 0xb9c8
leaq 0x42f1(%rip), %rsi      # 0xf6a3
leaq -0x88(%rbp), %rdi
leaq -0x21(%rbp), %rdx
callq 0x20a0
leaq 0x50c0(%r14), %r15
leaq -0x88(%rbp), %rsi
movq %r15, %rdi
movl %r12d, %edx
callq 0x85c6
leaq -0x88(%rbp), %rdi
callq 0x20d0
leaq 0x5050(%r14), %rdi
leaq 0x3c4a(%rip), %rsi      # 0xf03f
callq 0x7926
testb %al, %al
je 0xb46f
leaq 0x4408(%rip), %rsi      # 0xf80d
leaq -0x68(%rbp), %rdi
leaq -0x21(%rbp), %rdx
callq 0x20a0
movslq 0x2028(%r14), %rax
imulq $0xc, %rax, %rax
movl 0x2030(%r14,%rax), %edx
leaq -0x68(%rbp), %rsi
movq %r15, %rdi
callq 0x85c6
leaq -0x68(%rbp), %rdi
callq 0x20d0
movq %r14, %rdi
callq 0x9522
leaq 0x425a(%rip), %rsi      # 0xf6a3
leaq -0x48(%rbp), %rdi
leaq -0x21(%rbp), %rdx
callq 0x20a0
leaq -0x48(%rbp), %rsi
movq %r15, %rdi
movl %ebx, %edx
callq 0x85c6
leaq -0x48(%rbp), %rdi
callq 0x20d0
jmp 0xb477
movq %r14, %rdi
callq 0x9672
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
jmp 0xb4a4
jmp 0xb4ab
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
jmp 0xb4a4
jmp 0xb4ab
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0x20d0
jmp 0xb4ae
movq %rax, %rbx
movq %rbx, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O2/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::DoStat()
void Parse::DoStat()//do statement
{where="DS";check();
   int startL = newLabel(), loopL= newLabel(), pass1 = startL, pass2 = loopL;
   
   match();
   gen.emit2("DEFADDR", loopL);
   GarCmdList(pass1, pass2);
   if(LHS=="od")
   {
      gen.emit2("OD", ln[tokeNum][0]);
      match();
       gen.emit2("DEFADDR", startL);
   }else
	 errorReport();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movq %rdi, %r14
addq $0x5098, %rdi           # imm = 0x5098
leaq 0x433a(%rip), %rsi      # 0xf810
callq 0x2310
movq %r14, %rdi
callq 0x97e2
movl 0x71b0(%r14), %r12d
leal 0x1(%r12), %ebx
addl $0x2, %r12d
movl %r12d, 0x71b0(%r14)
movl %ebx, -0x28(%rbp)
movq %r14, %rdi
callq 0x9522
leaq 0x4197(%rip), %rsi      # 0xf6a3
leaq -0x88(%rbp), %rdi
leaq -0x21(%rbp), %rdx
callq 0x20a0
leaq 0x50c0(%r14), %r15
leaq -0x88(%rbp), %rsi
movq %r15, %rdi
movl %r12d, %edx
callq 0x85c6
leaq -0x88(%rbp), %rdi
callq 0x20d0
leaq -0x28(%rbp), %rsi
movq %r14, %rdi
movl %r12d, %edx
callq 0xb9c8
leaq 0x5050(%r14), %rdi
leaq 0x3df9(%rip), %rsi      # 0xf357
callq 0x7926
testb %al, %al
je 0xb5d8
leaq 0x42a5(%rip), %rsi      # 0xf813
leaq -0x68(%rbp), %rdi
leaq -0x21(%rbp), %rdx
callq 0x20a0
movslq 0x2028(%r14), %rax
imulq $0xc, %rax, %rax
movl 0x2030(%r14,%rax), %edx
leaq -0x68(%rbp), %rsi
movq %r15, %rdi
callq 0x85c6
leaq -0x68(%rbp), %rdi
callq 0x20d0
movq %r14, %rdi
callq 0x9522
leaq 0x40f1(%rip), %rsi      # 0xf6a3
leaq -0x48(%rbp), %rdi
leaq -0x21(%rbp), %rdx
callq 0x20a0
leaq -0x48(%rbp), %rsi
movq %r15, %rdi
movl %ebx, %edx
callq 0x85c6
leaq -0x48(%rbp), %rdi
callq 0x20d0
jmp 0xb5e0
movq %r14, %rdi
callq 0x9672
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
jmp 0xb60d
jmp 0xb614
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
jmp 0xb60d
jmp 0xb614
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0x20d0
jmp 0xb617
movq %rax, %rbx
movq %rbx, %rdi
callq 0x22e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::VarAcList()
void Parse::VarAcList()//variable access list
{where="VAL";check();
   if(LHS=="id")
   {
      tempSizeRead++;
      tempSizeAsn++;
      VarAc();
      VarAcListB();
   }else
      errorReport();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x5098, %rdi           # imm = 0x5098
leaq 0x4186(%rip), %rsi      # 0xf7bd
callq 0x2310
movq %rbx, %rdi
callq 0x97e2
leaq 0x5050(%rbx), %rdi
leaq 0x3d28(%rip), %rsi      # 0xf37a
callq 0x7926
testb %al, %al
je 0xb67d
incl 0x71f0(%rbx)
incl 0x71f8(%rbx)
movq %rbx, %rdi
callq 0xb68c
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xb848
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x9672
nop
// File: /workspace/github_cpp_makefile_star2_O2/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::VarAc()
void Parse::VarAc()//Variable access
{where="Va";check();
   
   if(LHS=="id")
   {

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x88, %rsp
movq %rdi, %rbx
addq $0x5098, %rdi           # imm = 0x5098
leaq 0x41ec(%rip), %rsi      # 0xf899
callq 0x2310
movq %rbx, %rdi
callq 0x97e2
leaq 0x5050(%rbx), %rdi
leaq 0x3cb2(%rip), %rsi      # 0xf37a
callq 0x7926
testb %al, %al
je 0xb801
movq %rbx, %rdi
callq 0xacf4
leaq 0x4c38(%rbx), %r15
movl 0x4ddc(%rbx), %edx
leaq -0x34(%rbp), %r14
movq %r14, %rdi
movq %r15, %rsi
callq 0xcb82
movups (%r14), %xmm0
movups 0xc(%r14), %xmm1
movups %xmm1, 0x4e1c(%rbx)
movups %xmm0, 0x4e10(%rbx)
leaq 0x4185(%rip), %rsi      # 0xf89c
leaq -0x98(%rbp), %rdi
leaq -0x34(%rbp), %rdx
callq 0x20a0
movl 0x4ddc(%rbx), %esi
movq %r15, %rdi
callq 0xcb3c
leaq 0x50c0(%rbx), %r14
movl 0x4e24(%rbx), %ecx
leaq -0x98(%rbp), %rsi
movq %r14, %rdi
movl %eax, %edx
callq 0x8630
leaq -0x98(%rbp), %rdi
callq 0x20d0
movl 0x4ddc(%rbx), %esi
movq %r15, %rdi
callq 0xc7d2
testb %al, %al
jne 0xb79a
leaq 0x412d(%rip), %rsi      # 0xf8a5
leaq -0x78(%rbp), %rdi
leaq -0x34(%rbp), %rdx
callq 0x20a0
leaq -0x78(%rbp), %rsi
movq %rbx, %rdi
callq 0x9890
leaq -0x78(%rbp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0xc594
cmpl $0x1, 0x71b4(%rbx)
jne 0xb7f3
leaq 0x4116(%rip), %rsi      # 0xf8c8
leaq -0x58(%rbp), %rdi
leaq -0x34(%rbp), %rdx
callq 0x20a0
movl 0x4e1c(%rbx), %edx
movslq 0x2028(%rbx), %rax
imulq $0xc, %rax, %rax
movl 0x2030(%rbx,%rax), %ecx
leaq -0x58(%rbp), %rsi
movq %r14, %rdi
callq 0x8630
leaq -0x58(%rbp), %rdi
callq 0x20d0
andl $0x0, 0x71b4(%rbx)
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movq %rbx, %rdi
addq $0x88, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x9672
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
jmp 0xb83b
jmp 0xb82c
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
jmp 0xb83b
jmp 0xb82c
movq %rax, %rbx
jmp 0xb840
movq %rax, %rbx
leaq -0x98(%rbp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O2/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::VarAcListB()
void Parse::VarAcListB()//variable access list for iterations
{where="VALB";check();
   if(LHS==",")
   {
      tempSizeRead++;
      tempSizeAsn++;
      match();
      
      VarAc();
      VarAcListB();
   }else
   {
      
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x5098(%rdi), %r14
leaq 0x5050(%rdi), %r15
leaq 0x3f53(%rip), %r12      # 0xf7c1
leaq 0x3af2(%rip), %r13      # 0xf367
movq %r14, %rdi
movq %r12, %rsi
callq 0x2310
movq %rbx, %rdi
callq 0x97e2
movq %r15, %rdi
movq %r13, %rsi
callq 0x7926
testb %al, %al
je 0xb8b5
incl 0x71f0(%rbx)
incl 0x71f8(%rbx)
movq %rbx, %rdi
callq 0x9522
movq %rbx, %rdi
callq 0xb68c
jmp 0xb875
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::ExpList()
void Parse::ExpList()//expression list
{where="EL";check();
   if(LHS!="-")
   {
      
      
   }
   tempSizeWrite++;
      Exp();
      ExpListB();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x5098, %rdi           # imm = 0x5098
leaq 0x3ef4(%rip), %rsi      # 0xf7cf
callq 0x2310
movq %rbx, %rdi
callq 0x97e2
leaq 0x5050(%rbx), %rdi
leaq 0x39da(%rip), %rsi      # 0xf2d0
callq 0x7a38
incl 0x71f4(%rbx)
movq %rbx, %rdi
callq 0xb918
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xb952
nop
// File: /workspace/github_cpp_makefile_star2_O2/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::ExpListB()
void Parse::ExpListB()//expression list for multiple iterations
{where="ELB";check();
   if(LHS==",")
   {
      tempSizeWrite++;
      match();
      Exp();
      ExpListB();
   }else
   {
      
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x5098(%rdi), %r14
leaq 0x5050(%rdi), %r15
leaq 0x3e5a(%rip), %r12      # 0xf7d2
leaq 0x39e8(%rip), %r13      # 0xf367
movq %r14, %rdi
movq %r12, %rsi
callq 0x2310
movq %rbx, %rdi
callq 0x97e2
movq %r15, %rdi
movq %r13, %rsi
callq 0x7926
testb %al, %al
je 0xb9b9
incl 0x71f4(%rbx)
movq %rbx, %rdi
callq 0x9522
movq %rbx, %rdi
callq 0xb918
jmp 0xb97f
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::GarCmd(int&, int)
void Parse::GarCmd(int &l1, int l2)//guarded command
{where="GC";check();

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

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x70, %rsp
movl %edx, %ebx
movq %rsi, %r12
movq %rdi, %r14
addq $0x5098, %rdi           # imm = 0x5098
leaq 0x3de0(%rip), %rsi      # 0xf81f
callq 0x2310
movq %r14, %rdi
callq 0x97e2
leaq 0x3c50(%rip), %rsi      # 0xf6a3
leaq -0x88(%rbp), %rdi
leaq -0x21(%rbp), %rdx
callq 0x20a0
leaq 0x50c0(%r14), %r15
movl (%r12), %edx
leaq -0x88(%rbp), %rsi
movq %r15, %rdi
callq 0x85c6
leaq -0x88(%rbp), %rdi
callq 0x20d0
movq %r14, %rdi
callq 0xb918
movl 0x71b0(%r14), %eax
incl %eax
movl %eax, 0x71b0(%r14)
movl %eax, (%r12)
leaq 0x5050(%r14), %rdi
leaq 0x38c4(%rip), %rsi      # 0xf377
callq 0x7926
testb %al, %al
je 0xbb26
leaq 0x3d5f(%rip), %rsi      # 0xf822
leaq -0x68(%rbp), %rdi
leaq -0x21(%rbp), %rdx
callq 0x20a0
movl (%r12), %edx
leaq -0x68(%rbp), %rsi
movq %r15, %rdi
callq 0x85c6
leaq -0x68(%rbp), %rdi
callq 0x20d0
movq %r14, %rdi
callq 0x9522
movq %r14, %rdi
callq 0xa1a4
leaq 0x3d28(%rip), %rsi      # 0xf828
leaq -0x48(%rbp), %rdi
leaq -0x21(%rbp), %rdx
callq 0x20a0
leaq -0x48(%rbp), %rsi
movq %r15, %rdi
movl %ebx, %edx
callq 0x85c6
leaq -0x48(%rbp), %rdi
callq 0x20d0
jmp 0xbb2e
movq %r14, %rdi
callq 0x9672
addq $0x70, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
leaq -0x48(%rbp), %rdi
jmp 0xbb5b
jmp 0xbb62
movq %rax, %rbx
leaq -0x68(%rbp), %rdi
jmp 0xbb5b
jmp 0xbb62
movq %rax, %rbx
leaq -0x88(%rbp), %rdi
callq 0x20d0
jmp 0xbb65
movq %rax, %rbx
movq %rbx, %rdi
callq 0x22e0
nop
// File: /workspace/github_cpp_makefile_star2_O2/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::GarCmdListB(int&, int)
void Parse::GarCmdListB(int &l1, int l2)//guarded command list for multiple iterations
{where="GCLB";check();
   if(LHS=="["||LHS=="[]")
   {
      match();
      if(LHS=="]"||NS=="[]")
      {
	 match();
	 GarCmd(l1, l2);
	 GarCmdListB(l1, l2);
      }else
	 errorReport();
   }else
   {
      
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %ebx
movq %rsi, %r15
movq %rdi, %r14
leaq 0x5098(%rdi), %r12
leaq 0x5050(%rdi), %r13
leaq 0x5070(%rdi), %rax
movq %rax, -0x30(%rbp)
movq %r12, %rdi
leaq 0x3c73(%rip), %rsi      # 0xf81a
callq 0x2310
movq %r14, %rdi
callq 0x97e2
movq %r13, %rdi
leaq 0x3a9b(%rip), %rsi      # 0xf659
callq 0x7926
testb %al, %al
jne 0xbbda
movq %r13, %rdi
leaq 0x37a0(%rip), %rsi      # 0xf371
callq 0x7926
testb %al, %al
je 0xbc23
movq %r14, %rdi
callq 0x9522
movq %r13, %rdi
leaq 0x3786(%rip), %rsi      # 0xf372
callq 0x7926
testb %al, %al
jne 0xbc09
movq -0x30(%rbp), %rdi
leaq 0x3771(%rip), %rsi      # 0xf371
callq 0x7926
testb %al, %al
je 0xbc32
movq %r14, %rdi
callq 0x9522
movq %r14, %rdi
movq %r15, %rsi
movl %ebx, %edx
callq 0xba1a
jmp 0xbb9d
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x9672
// File: /workspace/github_cpp_makefile_star2_O2/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::ExpB()
void Parse::ExpB()//expression for multiple iterations
{where="EB";check();
   if(LHS=="|"||LHS=="&")
   {
      PrimOp();
      PrimExp();
      ExpB();
   }else
   {
      
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x5098(%rdi), %r14
leaq 0x5050(%rdi), %r15
leaq 0x3b92(%rip), %r12      # 0xf83a
leaq 0x36bc(%rip), %r13      # 0xf36b
movq %r14, %rdi
movq %r12, %rsi
callq 0x2310
movq %rbx, %rdi
callq 0x97e2
movq %r15, %rdi
movq %r13, %rsi
callq 0x7926
testb %al, %al
jne 0xbce4
movq %r15, %rdi
leaq 0x368e(%rip), %rsi      # 0xf369
callq 0x7926
testb %al, %al
je 0xbcf6
movq %rbx, %rdi
callq 0xbd06
movq %rbx, %rdi
callq 0xbc48
jmp 0xbcaf
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::PrimOp()
void Parse::PrimOp()//primary operations
{where="PO";check();
   if(LHS=="&")
   {
      gen.emit1("AND");
      match();
   }else if(LHS=="|")
   {
      gen.emit1("OR");
      match();
   }else
      errorReport();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
addq $0x5098, %rdi           # imm = 0x5098
leaq 0x3b0a(%rip), %rsi      # 0xf82c
callq 0x2310
movq %rbx, %rdi
callq 0x97e2
leaq 0x5050(%rbx), %r14
leaq 0x362c(%rip), %rsi      # 0xf369
movq %r14, %rdi
callq 0x7926
testb %al, %al
je 0xbd73
leaq 0x3adf(%rip), %rsi      # 0xf82f
leaq -0x58(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0x20a0
leaq 0x50c0(%rbx), %rdi
leaq -0x58(%rbp), %rsi
callq 0x8572
leaq -0x58(%rbp), %rdi
jmp 0xbdae
leaq 0x35f1(%rip), %rsi      # 0xf36b
movq %r14, %rdi
callq 0x7926
testb %al, %al
je 0xbdc4
leaq 0x3aa6(%rip), %rsi      # 0xf833
leaq -0x38(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0x20a0
leaq 0x50c0(%rbx), %rdi
leaq -0x38(%rbp), %rsi
callq 0x8572
leaq -0x38(%rbp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x9522
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x9672
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
jmp 0xbde6
jmp 0xbded
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x20d0
jmp 0xbdf0
movq %rax, %rbx
movq %rbx, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O2/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::SimpExp()
void Parse::SimpExp()//simple expression
{where="SE";check();
   Line();
   Term();
   SimpExpB();

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x5098, %rdi           # imm = 0x5098
leaq 0x3a44(%rip), %rsi      # 0xf853
callq 0x2310
movq %rbx, %rdi
callq 0x97e2
movq %rbx, %rdi
callq 0xbff2
movq %rbx, %rdi
callq 0xc042
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xc07c
// File: /workspace/github_cpp_makefile_star2_O2/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::PrimExpB()
void Parse::PrimExpB()//primary expression for multiple iterations
{where="PEB";check();
   if(LHS=="<"||LHS=="="||LHS==">")
   {
      RelatOp();
      SimpExp();
   }else
   {
      
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
addq $0x5098, %rdi           # imm = 0x5098
leaq 0x39e7(%rip), %rsi      # 0xf839
callq 0x2310
movq %rbx, %rdi
callq 0x97e2
leaq 0x5050(%rbx), %r14
leaq 0x3502(%rip), %rsi      # 0xf36f
movq %r14, %rdi
callq 0x7926
testb %al, %al
jne 0xbe9f
leaq 0x34f5(%rip), %rsi      # 0xf375
movq %r14, %rdi
callq 0x7926
testb %al, %al
jne 0xbe9f
leaq 0x34e5(%rip), %rsi      # 0xf378
movq %r14, %rdi
callq 0x7926
testb %al, %al
je 0xbeb3
movq %rbx, %rdi
callq 0xbeb8
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0xbdf8
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
addq $0x5098, %rdi           # imm = 0x5098
leaq 0x3969(%rip), %rsi      # 0xf83d
callq 0x2310
movq %rbx, %rdi
callq 0x97e2
leaq 0x5050(%rbx), %r14
leaq 0x3480(%rip), %rsi      # 0xf36f
movq %r14, %rdi
callq 0x7926
testb %al, %al
je 0xbf25
leaq 0x393e(%rip), %rsi      # 0xf840
leaq -0x78(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0x20a0
leaq 0x50c0(%rbx), %rdi
leaq -0x78(%rbp), %rsi
callq 0x8572
leaq -0x78(%rbp), %rdi
jmp 0xbf9d
leaq 0x3449(%rip), %rsi      # 0xf375
movq %r14, %rdi
callq 0x7926
testb %al, %al
je 0xbf62
leaq 0x3906(%rip), %rsi      # 0xf845
leaq -0x58(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0x20a0
leaq 0x50c0(%rbx), %rdi
leaq -0x58(%rbp), %rsi
callq 0x8572
leaq -0x58(%rbp), %rdi
jmp 0xbf9d
leaq 0x340f(%rip), %rsi      # 0xf378
movq %r14, %rdi
callq 0x7926
testb %al, %al
je 0xbfb3
leaq 0x38cf(%rip), %rsi      # 0xf84b
leaq -0x38(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0x20a0
leaq 0x50c0(%rbx), %rdi
leaq -0x38(%rbp), %rsi
callq 0x8572
leaq -0x38(%rbp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x9522
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x9672
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
jmp 0xbfe0
jmp 0xbfe7
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
jmp 0xbfe0
jmp 0xbfe7
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x20d0
jmp 0xbfea
movq %rax, %rbx
movq %rbx, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
pushq %rax
movq %rdi, %rbx
addq $0x5098, %rdi           # imm = 0x5098
leaq 0x3840(%rip), %rsi      # 0xf849
callq 0x2310
movq %rbx, %rdi
callq 0x97e2
leaq 0x5050(%rbx), %rdi
leaq 0x32ac(%rip), %rsi      # 0xf2d0
callq 0x7926
testb %al, %al
je 0xc03b
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x9522
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::SimpExpB()
void Parse::SimpExpB()//simple expression for multiple iterations
{where="SEB";check();
   if(LHS=="-"||LHS=="+")
   {
      AddOp();
      Term();
      SimpExpB();
   }else
   {

   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x5098(%rdi), %r14
leaq 0x5050(%rdi), %r15
leaq 0x37b4(%rip), %r12      # 0xf856
leaq 0x3227(%rip), %r13      # 0xf2d0
movq %r14, %rdi
movq %r12, %rsi
callq 0x2310
movq %rbx, %rdi
callq 0x97e2
movq %r15, %rdi
movq %r13, %rsi
callq 0x7926
testb %al, %al
jne 0xc0de
movq %r15, %rdi
leaq 0x31f9(%rip), %rsi      # 0xf2ce
callq 0x7926
testb %al, %al
je 0xc0f0
movq %rbx, %rdi
callq 0xc100
movq %rbx, %rdi
callq 0xc042
jmp 0xc0a9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x50, %rsp
movq %rdi, %rbx
addq $0x5098, %rdi           # imm = 0x5098
leaq 0x373e(%rip), %rsi      # 0xf85a
callq 0x2310
movq %rbx, %rdi
callq 0x97e2
leaq 0x5050(%rbx), %r14
leaq 0x3197(%rip), %rsi      # 0xf2ce
movq %r14, %rdi
callq 0x7926
testb %al, %al
je 0xc16d
leaq 0x3713(%rip), %rsi      # 0xf85d
leaq -0x58(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0x20a0
leaq 0x50c0(%rbx), %rdi
leaq -0x58(%rbp), %rsi
callq 0x8572
leaq -0x58(%rbp), %rdi
jmp 0xc1a8
leaq 0x315c(%rip), %rsi      # 0xf2d0
movq %r14, %rdi
callq 0x7926
testb %al, %al
je 0xc1be
leaq 0x36da(%rip), %rsi      # 0xf861
leaq -0x38(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0x20a0
leaq 0x50c0(%rbx), %rdi
leaq -0x38(%rbp), %rsi
callq 0x8572
leaq -0x38(%rbp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x9522
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
addq $0x50, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x9672
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
jmp 0xc1e0
jmp 0xc1e7
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
callq 0x20d0
jmp 0xc1ea
movq %rax, %rbx
movq %rbx, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O2/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::Factor()
void Parse::Factor()//factor
{where="F";check();
   if(LHS=="num"||LHS=="false"||LHS=="true")
   {
      Const();
      gen.emit2("CONSTANT", tpVl);
      
   }else if(LHS=="id")
   {
      VarAc();
      gen.emit1("VALUE");
   }else if(LHS=="(")
   {
      match();
      Exp();
      if(LHS==")")
      {
	 match();
      }else
	 errorReport();
   }else if(LHS=="~")
   {
      gen.emit1("NOT");
      match();
      Factor();
   }else
      errorReport();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
addq $0x5098, %rdi           # imm = 0x5098
leaq 0x3676(%rip), %rsi      # 0xf884
callq 0x2310
movq %rbx, %rdi
callq 0x97e2
leaq 0x5050(%rbx), %r14
leaq 0x309b(%rip), %rsi      # 0xf2c4
movq %r14, %rdi
callq 0x7926
testb %al, %al
jne 0xc25b
leaq 0x311e(%rip), %rsi      # 0xf35a
movq %r14, %rdi
callq 0x7926
testb %al, %al
jne 0xc25b
leaq 0x3111(%rip), %rsi      # 0xf360
movq %r14, %rdi
callq 0x7926
testb %al, %al
je 0xc2a2
movq %rbx, %rdi
callq 0xa7d6
leaq 0x361c(%rip), %rsi      # 0xf886
leaq -0x78(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0x20a0
movl 0x7228(%rbx), %edx
addq $0x50c0, %rbx           # imm = 0x50C0
leaq -0x78(%rbp), %rsi
movq %rbx, %rdi
callq 0x85c6
leaq -0x78(%rbp), %rdi
callq 0x20d0
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
leaq 0x30d1(%rip), %rsi      # 0xf37a
movq %r14, %rdi
callq 0x7926
testb %al, %al
je 0xc2ea
movq %rbx, %rdi
callq 0xb68c
leaq 0x35cb(%rip), %rsi      # 0xf88f
leaq -0x58(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0x20a0
addq $0x50c0, %rbx           # imm = 0x50C0
leaq -0x58(%rbp), %rsi
movq %rbx, %rdi
callq 0x8572
leaq -0x58(%rbp), %rdi
jmp 0xc294
leaq 0x2fe3(%rip), %rsi      # 0xf2d4
movq %r14, %rdi
callq 0x7926
testb %al, %al
je 0xc330
movq %rbx, %rdi
callq 0x9522
movq %rbx, %rdi
callq 0xb918
leaq 0x3165(%rip), %rsi      # 0xf479
movq %r14, %rdi
callq 0x7926
testb %al, %al
je 0xc385
movq %rbx, %rdi
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x9522
leaq 0x3036(%rip), %rsi      # 0xf36d
movq %r14, %rdi
callq 0x7926
testb %al, %al
je 0xc385
leaq 0x354b(%rip), %rsi      # 0xf895
leaq -0x38(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0x20a0
leaq 0x50c0(%rbx), %rdi
leaq -0x38(%rbp), %rsi
callq 0x8572
leaq -0x38(%rbp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x9522
movq %rbx, %rdi
callq 0xc1f2
jmp 0xc299
movq %rbx, %rdi
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x9672
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
jmp 0xc3b2
jmp 0xc3b9
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
jmp 0xc3b2
jmp 0xc3b9
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x20d0
jmp 0xc3bc
movq %rax, %rbx
movq %rbx, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O2/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::TermB()
void Parse::TermB()//term for multiple iterations
{where="TB";check();
   if(LHS=="*"||LHS=="%"||LHS=="/")
   {
      MultOp();
      Factor();
      TermB();
   }else
   {

   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x5098(%rdi), %r14
leaq 0x5050(%rdi), %r15
leaq 0x3480(%rip), %r12      # 0xf86a
leaq 0x2ee1(%rip), %r13      # 0xf2d2
movq %r14, %rdi
movq %r12, %rsi
callq 0x2310
movq %rbx, %rdi
callq 0x97e2
movq %r15, %rdi
movq %r13, %rsi
callq 0x7926
testb %al, %al
jne 0xc439
movq %r15, %rdi
leaq 0x2ead(%rip), %rsi      # 0xf2ca
callq 0x7926
testb %al, %al
jne 0xc439
movq %r15, %rdi
leaq 0x2e98(%rip), %rsi      # 0xf2c8
callq 0x7926
testb %al, %al
je 0xc44b
movq %rbx, %rdi
callq 0xc45a
movq %rbx, %rdi
callq 0xc1f2
jmp 0xc3f1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x70, %rsp
movq %rdi, %rbx
addq $0x5098, %rdi           # imm = 0x5098
leaq 0x33f7(%rip), %rsi      # 0xf86d
callq 0x2310
movq %rbx, %rdi
callq 0x97e2
leaq 0x5050(%rbx), %r14
leaq 0x2e41(%rip), %rsi      # 0xf2d2
movq %r14, %rdi
callq 0x7926
testb %al, %al
je 0xc4c7
leaq 0x33cc(%rip), %rsi      # 0xf870
leaq -0x78(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0x20a0
leaq 0x50c0(%rbx), %rdi
leaq -0x78(%rbp), %rsi
callq 0x8572
leaq -0x78(%rbp), %rdi
jmp 0xc53f
leaq 0x2dfc(%rip), %rsi      # 0xf2ca
movq %r14, %rdi
callq 0x7926
testb %al, %al
je 0xc504
leaq 0x3395(%rip), %rsi      # 0xf876
leaq -0x58(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0x20a0
leaq 0x50c0(%rbx), %rdi
leaq -0x58(%rbp), %rsi
callq 0x8572
leaq -0x58(%rbp), %rdi
jmp 0xc53f
leaq 0x2dbd(%rip), %rsi      # 0xf2c8
movq %r14, %rdi
callq 0x7926
testb %al, %al
je 0xc555
leaq 0x335f(%rip), %rsi      # 0xf87d
leaq -0x38(%rbp), %rdi
leaq -0x11(%rbp), %rdx
callq 0x20a0
leaq 0x50c0(%rbx), %rdi
leaq -0x38(%rbp), %rsi
callq 0x8572
leaq -0x38(%rbp), %rdi
callq 0x20d0
movq %rbx, %rdi
callq 0x9522
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
retq
movq %rbx, %rdi
addq $0x70, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x9672
movq %rax, %rbx
leaq -0x38(%rbp), %rdi
jmp 0xc582
jmp 0xc589
movq %rax, %rbx
leaq -0x58(%rbp), %rdi
jmp 0xc582
jmp 0xc589
movq %rax, %rbx
leaq -0x78(%rbp), %rdi
callq 0x20d0
jmp 0xc58c
movq %rax, %rbx
movq %rbx, %rdi
callq 0x22e0
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq 0x3323(%rip), %rsi      # 0xf8ce
callq 0x2310
movq %rbx, %rdi
callq 0x97e2
leaq 0x5050(%rbx), %rdi
leaq 0x3093(%rip), %rsi      # 0xf659
callq 0x7926
testb %al, %al
je 0xc5e7
movl $0x1, 0x71b4(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0xc5ee
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
movq %rdi, %rbx
addq $0x5098, %rdi           # imm = 0x5098
leaq 0x3204(%rip), %rsi      # 0xf80a
callq 0x2310
movq %rbx, %rdi
callq 0x97e2
leaq 0x5050(%rbx), %r14
leaq 0x3038(%rip), %rsi      # 0xf659
movq %r14, %rdi
callq 0x7926
testb %al, %al
je 0xc65c
movq %rbx, %rdi
callq 0x9522
movq %rbx, %rdi
callq 0xb918
leaq 0x2d2e(%rip), %rsi      # 0xf372
movq %r14, %rdi
callq 0x7926
testb %al, %al
je 0xc65c
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x9522
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
pushq %rax
movq %rdi, %rbx
addq $0x5098, %rdi           # imm = 0x5098
leaq 0x3260(%rip), %rsi      # 0xf8d9
callq 0x2310
movq %rbx, %rdi
callq 0x97e2
leaq 0x5050(%rbx), %rdi
leaq 0x2c30(%rip), %rsi      # 0xf2c4
callq 0x7926
testb %al, %al
je 0xc6c9
movslq 0x2028(%rbx), %rax
imulq $0xc, %rax, %rax
movl 0x2038(%rbx,%rax), %eax
movl %eax, 0x4de4(%rbx)
movl %eax, 0x7228(%rbx)
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x9522
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x9672
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
movq %rdi, %rbx
addq $0x5098, %rdi           # imm = 0x5098
leaq 0x31e2(%rip), %rsi      # 0xf8d2
callq 0x2310
movq %rbx, %rdi
callq 0x97e2
leaq 0x5050(%rbx), %r14
leaq 0x2c4f(%rip), %rsi      # 0xf35a
movq %r14, %rdi
callq 0x7926
testb %al, %al
je 0xc72f
andl $0x0, 0x4de4(%rbx)
movslq 0x4d88(%rbx), %rax
andl $0x0, 0x4d60(%rbx,%rax,4)
jmp 0xc759
leaq 0x2c2a(%rip), %rsi      # 0xf360
movq %r14, %rdi
callq 0x7926
testb %al, %al
je 0xc771
pushq $0x1
popq %rax
movl %eax, 0x4de4(%rbx)
movslq 0x4d88(%rbx), %rcx
movl %eax, 0x4d60(%rbx,%rcx,4)
movl 0x4de4(%rbx), %eax
movl %eax, 0x7228(%rbx)
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x9522
movq %rbx, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x9672
nopl (%rax)
// File: /workspace/github_cpp_makefile_star2_O2/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
addq $0x8, %rdi
xorl %ecx, %ecx
testl %eax, %eax
movl $0x0, %edx
cmovgl %eax, %edx
cmpq %rdx, %rcx
je 0xc81b
imulq $0x18, %rcx, %r8
movq (%rdi,%r8), %r9
movq 0x8(%rdi,%r8), %r8
cmpq %r8, %r9
je 0xc812
leaq 0x1c(%r9), %r10
cmpl %esi, (%r9)
movq %r10, %r9
jne 0xc7ff
jmp 0xc817
incq %rcx
jmp 0xc7ed
movb $0x1, %al
popq %rbp
retq
imulq $0x18, %rax, %rax
movq (%rdi,%rax), %rdx
movq 0x8(%rdi,%rax), %rcx
cmpq %rcx, %rdx
setne %al
je 0xc819
leaq 0x1c(%rdx), %rdi
cmpl %esi, (%rdx)
movq %rdi, %rdx
jne 0xc828
jmp 0xc819
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0xc8e8
cmpb $0x0, (%r15)
je 0xc883
xorl %eax, %eax
jmp 0xc8d9
cmpl $0x3, -0x4c(%rbp)
jne 0xc898
movq %rbx, %rdi
movl %r14d, %esi
callq 0xc7d2
testb %al, %al
jne 0xc87f
movl 0x18(%rbp), %eax
movl 0x10(%rbp), %ecx
leaq -0x50(%rbp), %rsi
movl %r14d, (%rsi)
movl %r13d, 0x4(%rsi)
movl %r12d, 0x8(%rsi)
movl -0x30(%rbp), %edx
movl %edx, 0xc(%rsi)
movl -0x34(%rbp), %edx
movl %edx, 0x10(%rsi)
movl %ecx, 0x14(%rsi)
movl %eax, 0x18(%rsi)
movslq 0xf8(%rbx), %rax
imulq $0x18, %rax, %rax
leaq (%rbx,%rax), %rdi
addq $0x8, %rdi
callq 0xcc0e
movb $0x1, %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
pushq %rbp
movq %rsp, %rbp
movl %edx, %r8d
movslq 0xf8(%rsi), %rax
imulq $0x18, %rax, %rax
movq 0x8(%rsi,%rax), %r9
movq 0x10(%rsi,%rax), %rax
subq %r9, %rax
movabsq $0x1c, %r10
cqto
idivq %r10
incq %rax
decq %rax
je 0xc957
leaq 0x1c(%r9), %rdx
cmpl %r8d, (%r9)
movq %rdx, %r9
jne 0xc919
movb $0x1, %al
movb %al, (%rcx)
movb %al, (%rsi)
movl %r8d, (%rdi)
movl -0x18(%rdx), %eax
movl %eax, 0x4(%rdi)
movl -0x14(%rdx), %eax
movl %eax, 0x8(%rdi)
movl -0x10(%rdx), %eax
movl %eax, 0xc(%rdi)
movl -0xc(%rdx), %eax
movl %eax, 0x10(%rdi)
movl -0x8(%rdx), %eax
movl %eax, 0x14(%rdi)
movl -0x4(%rdx), %eax
movl %eax, 0x18(%rdi)
movq %rdi, %rax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq 0xf8(%rdi), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
addq $0x8, %rdi
movq (%rdi), %rsi
movq 0x8(%rdi), %rdx
callq 0xcc3a
movl 0xf8(%rbx), %eax
testl %eax, %eax
js 0xc9b5
decl %eax
movl %eax, 0xf8(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/navrajsaini[P]PL_Compiler_design_project/BlockTable.cpp
// Function: BlockTable::printtable()
void BlockTable::printtable()
{
   int ind = 0;
   for (vector<TableEntry>::iterator j = table[blockLevel].begin();
	j != table[blockLevel].end(); ++j)
   {
      cout << "location: " << ind+1 << endl
	   << "   index: " << j -> idindex << endl
	   << "   kind:  " << j -> kind << endl
	   << "   type:  " << j -> type << endl
	   << "   size:  " << j -> size << endl
	   << "   value: " << j -> value << endl
	   << "   disp:  " << j -> disp << endl
	   << "   Label: " << j -> procLabel << endl;
      ind++;
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x8(%rdi), %r15
movslq 0xf8(%rdi), %rax
imulq $0x18, %rax, %rcx
movq 0x8(%rdi,%rcx), %r12
pushq $0x1
popq %r14
leaq 0x2f3f(%rip), %r13      # 0xf92b
cltq
imulq $0x18, %rax, %rax
cmpq 0x8(%r15,%rax), %r12
je 0xcb2c
movq 0x85c4(%rip), %rdi      # 0x14fc8
leaq 0x2ed3(%rip), %rsi      # 0xf8de
callq 0x21a0
movq %rax, %rdi
movl %r14d, %esi
callq 0x22c0
movq %rax, %rdi
callq 0x20f0
movq %rax, %rdi
leaq 0x2ebc(%rip), %rsi      # 0xf8e9
callq 0x21a0
movl (%r12), %esi
movq %rax, %rdi
callq 0x22c0
movq %rax, %rdi
callq 0x20f0
movq %rax, %rdi
leaq 0x2ea4(%rip), %rsi      # 0xf8f4
callq 0x21a0
movl 0x4(%r12), %esi
movq %rax, %rdi
callq 0x22c0
movq %rax, %rdi
callq 0x20f0
movq %rax, %rdi
leaq 0x2e8b(%rip), %rsi      # 0xf8ff
callq 0x21a0
movl 0x8(%r12), %esi
movq %rax, %rdi
callq 0x22c0
movq %rax, %rdi
callq 0x20f0
movq %rax, %rdi
leaq 0x2e72(%rip), %rsi      # 0xf90a
callq 0x21a0
movl 0xc(%r12), %esi
movq %rax, %rdi
callq 0x22c0
movq %rax, %rdi
callq 0x20f0
movq %rax, %rdi
leaq 0x2e59(%rip), %rsi      # 0xf915
callq 0x21a0
movl 0x10(%r12), %esi
movq %rax, %rdi
callq 0x22c0
movq %rax, %rdi
callq 0x20f0
movq %rax, %rdi
leaq 0x2e40(%rip), %rsi      # 0xf920
callq 0x21a0
movl 0x14(%r12), %esi
movq %rax, %rdi
callq 0x22c0
movq %rax, %rdi
callq 0x20f0
movq %rax, %rdi
movq %r13, %rsi
callq 0x21a0
movl 0x18(%r12), %esi
movq %rax, %rdi
callq 0x22c0
movq %rax, %rdi
callq 0x20f0
addq $0x1c, %r12
movl 0xf8(%rbx), %eax
incl %r14d
jmp 0xc9ec
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/navrajsaini[P]PL_Compiler_design_project/BlockTable.cpp
// Function: BlockTable::loc(int)
int BlockTable::loc (int index)
{
   for (int i = blockLevel; i >= 0; i--)
   //go through all the blocks from the current block
   {
      for (auto it = table[i].begin(); it != table[i].end(); ++it)
      //check all the entries in the block level
    	 if (it -> idindex == index)
       //if it matches return the differnece in the block levels
    	 {
    	    return (blockLevel - i);
    	 }
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0xf8(%rdi), %eax
addq $0x8, %rdi
movl %eax, %ecx
movl %ecx, %edx
imulq $0x18, %rdx, %rdx
movq (%rdi,%rdx), %r8
movq 0x8(%rdi,%rdx), %rdx
cmpq %rdx, %r8
je 0xcb6e
leaq 0x1c(%r8), %r9
cmpl %esi, (%r8)
movq %r9, %r8
jne 0xcb5b
jmp 0xcb72
decl %ecx
jmp 0xcb4c
subl %ecx, %eax
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq 0x8(%rsi), %rcx
movslq 0xf8(%rsi), %rdi
imulq $0x18, %rdi, %r9
movq 0x8(%rsi,%r9), %r8
movq 0x10(%rsi,%r9), %r9
cmpq %r9, %r8
je 0xcbb2
cmpl %edx, (%r8)
je 0xcbdd
addq $0x1c, %r8
jmp 0xcba2
movb $0x0, (%rsi)
testl %edi, %edi
js 0xcc0c
movl %edi, %r8d
imulq $0x18, %r8, %r9
movq (%rcx,%r9), %r8
movq 0x8(%rcx,%r9), %r9
cmpq %r9, %r8
je 0xcbd9
cmpl %edx, (%r8)
je 0xcbdd
addq $0x1c, %r8
jmp 0xcbc9
decl %edi
jmp 0xcbb5
movl %edx, (%rax)
movl 0x4(%r8), %ecx
movl %ecx, 0x4(%rax)
movl 0x8(%r8), %ecx
movl %ecx, 0x8(%rax)
movl 0xc(%r8), %ecx
movl %ecx, 0xc(%rax)
movl 0x10(%r8), %ecx
movl %ecx, 0x10(%rax)
movl 0x14(%r8), %ecx
movl %ecx, 0x14(%rax)
movl 0x18(%r8), %ecx
movl %ecx, 0x18(%rax)
movb $0x1, (%rsi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
andl $0x0, 0x7d0(%rdi)
xorl %eax, %eax
cmpq $0x1f4, %rax            # imm = 0x1F4
je 0xce42
andl $0x0, (%rdi,%rax,4)
incq %rax
jmp 0xce31
movq %rsi, 0x7d8(%rdi)
movq %rdx, 0x7e0(%rdi)
popq %rbp
retq