LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/ralgond[P]SortedListIntersection/algo_scalar.cpp
// Function: scalar(unsigned int const*, unsigned long, unsigned int const*, unsigned long, unsigned int*)
size_t scalar(const uint32_t *A, const size_t lenA, const uint32_t *B,
              const size_t lenB, uint32_t *out) {
  const uint32_t *const initout(out);
  if (lenA == 0 || lenB == 0)
    return 0;

  const uint32_t *endA = A + lenA;
  const uint32_t *endB = B + lenB;

  while (1) {
    while (*A < *B) {
    SKIP_FIRST_COMPARE:
      if (++A == endA)
        return (out - initout);
    }
    while (*A > *B) {
      if (++B == endB)
        return (out - initout);
    }
    if (*A == *B) {
      *out++ = *A;
      if (++A == endA || ++B == endB)
        return (out - initout);
    } else {
      goto SKIP_FIRST_COMPARE;
    }
  }

  return (out - initout); // NOTREACHED
}

// Assembly:
testq %rsi, %rsi
sete %al
testq %rcx, %rcx
sete %r9b
orb %al, %r9b
je 0x4499
xorl %eax, %eax
retq
leaq (%rdi,%rsi,4), %rsi
leaq (%rdx,%rcx,4), %rcx
movq %r8, %rax
movl (%rdi), %r9d
cmpl (%rdx), %r9d
jb 0x44be
cmpl (%rdx), %r9d
jbe 0x44bc
addq $0x4, %rdx
cmpq %rcx, %rdx
jne 0x44ac
jmp 0x44e2
je 0x44c9
addq $0x4, %rdi
cmpq %rsi, %rdi
jne 0x44a4
jmp 0x44e2
movl %r9d, (%rax)
addq $0x4, %rax
addq $0x4, %rdi
cmpq %rsi, %rdi
je 0x44e2
addq $0x4, %rdx
cmpq %rcx, %rdx
jne 0x44a4
subq %r8, %rax
sarq $0x2, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/ralgond[P]SortedListIntersection/algo_scalar.cpp
// Function: match_scalar(unsigned int const*, unsigned long, unsigned int const*, unsigned long, unsigned int*)
size_t match_scalar(const uint32_t *A, const size_t lenA, const uint32_t *B, const size_t lenB, uint32_t *out) {

  const uint32_t *initout = out;
  if (lenA == 0 || lenB == 0)
    return 0;

  const uint32_t *endA = A + lenA;
  const uint32_t *endB = B + lenB;

  while (1) {
    while (*A < *B) {
    SKIP_FIRST_COMPARE:
      if (++A == endA)
        goto FINISH;
    }
    while (*A > *B) {
      if (++B == endB)
        goto FINISH;
    }
    if (*A == *B) {
      *out++ = *A;
      if (++A == endA || ++B == endB)
        goto FINISH;
    } else {
      goto SKIP_FIRST_COMPARE;
    }
  }

FINISH:
  return (out - initout);
}

// Assembly:
testq %rsi, %rsi
sete %al
testq %rcx, %rcx
sete %r9b
orb %al, %r9b
je 0x44ff
xorl %eax, %eax
retq
leaq (%rdi,%rsi,4), %rsi
leaq (%rdx,%rcx,4), %rcx
movq %r8, %rax
movl (%rdi), %r9d
cmpl (%rdx), %r9d
jb 0x4524
cmpl (%rdx), %r9d
jbe 0x4522
addq $0x4, %rdx
cmpq %rcx, %rdx
jne 0x4512
jmp 0x4548
je 0x452f
addq $0x4, %rdi
cmpq %rsi, %rdi
jne 0x450a
jmp 0x4548
movl %r9d, (%rax)
addq $0x4, %rax
addq $0x4, %rdi
cmpq %rsi, %rdi
je 0x4548
addq $0x4, %rdx
cmpq %rcx, %rdx
jne 0x450a
subq %r8, %rax
sarq $0x2, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/ralgond[P]SortedListIntersection/sorted_int_file_reader.cpp
// Function: read_sorted_int_from_file(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, unsigned int*)
uint32_t* read_sorted_int_from_file(string filepath, uint32_t* size) {
	ifstream inf(filepath);
	if (inf) {
		vector<uint32_t> v;
		string line;
		while (getline(inf, line)) {
			int num = atoi(line.c_str());
			v.push_back(num);
		}

		*size = v.size();
		uint32_t* ret = new uint32_t[*size];
		for (int i = 0; i < v.size(); i++) {
			ret[i] = v.at(i);
		}
		return ret;
	} else {
		return NULL;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x258, %rsp            # imm = 0x258
movq %rsi, %rbx
movq %rdi, %rsi
leaq 0x50(%rsp), %r14
movq %r14, %rdi
movl $0x8, %edx
callq 0x21c0
movq (%r14), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x70(%rsp,%rax)
je 0x555e
xorl %ebx, %ebx
jmp 0x566c
vxorps %xmm0, %xmm0, %xmm0
leaq 0x10(%rsp), %r15
vmovaps %xmm0, (%r15)
xorl %eax, %eax
movq %rax, 0x10(%r15)
leaq 0x40(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq %rax, -0x8(%rbp)
movb $0x0, (%rbp)
leaq 0x30(%rsp), %r12
leaq 0xc(%rsp), %r13
movq 0x50(%rsp), %rax
movq -0x18(%rax), %rdi
addq %r14, %rdi
movl $0xa, %esi
callq 0x2150
movsbl %al, %edx
movq %r14, %rdi
movq %r12, %rsi
callq 0x2220
movq (%rax), %rcx
movq -0x18(%rcx), %rcx
testb $0x5, 0x20(%rax,%rcx)
jne 0x55f3
movq 0x30(%rsp), %rdi
callq 0x21a0
movl %eax, 0xc(%rsp)
movq 0x18(%rsp), %rsi
cmpq 0x20(%rsp), %rsi
je 0x55e6
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x18(%rsp)
jmp 0x558d
movq %r15, %rdi
movq %r13, %rdx
callq 0x56d2
jmp 0x558d
movq 0x10(%rsp), %r14
movq 0x18(%rsp), %r12
movq %r12, %r15
subq %r14, %r15
movabsq $0x3fffffffc, %rdi      # imm = 0x3FFFFFFFC
andq %r15, %rdi
sarq $0x2, %r15
movl %r15d, (%rbx)
callq 0x2030
movq %rax, %rbx
cmpq %r14, %r12
je 0x563e
cmpq $0x1, %r15
adcq $0x0, %r15
shlq $0x2, %r15
movq %rbx, %rdi
movq %r14, %rsi
movq %r15, %rdx
callq 0x2110
movq 0x30(%rsp), %rdi
cmpq %rbp, %rdi
je 0x5655
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x2170
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x566c
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x2170
leaq 0x50(%rsp), %rdi
callq 0x2050
movq %rbx, %rax
addq $0x258, %rsp            # imm = 0x258
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x568f
jmp 0x568f
movq %rax, %rbx
movq 0x30(%rsp), %rdi
cmpq %rbp, %rdi
je 0x56a9
movq 0x40(%rsp), %rsi
incq %rsi
callq 0x2170
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x56c0
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x2170
leaq 0x50(%rsp), %rdi
callq 0x2050
movq %rbx, %rdi
callq 0x2200
// File: /workspace/github_cpp_makefile_star2_O1/ralgond[P]SortedListIntersection/utils.cpp
// Function: bisearch(unsigned int const*, unsigned int, unsigned int)
int bisearch(const uint32_t* a, uint32_t a_len, uint32_t target) {
	int low = 0;
	int high = a_len - 1;

	while (high-low > 4) {
		int mid = low + (high-low) / 2;
		int mid_v = a[mid];
		if (mid_v == target)
			return mid;
		else if (target < mid_v)
			high = mid - 1;
		else
			low = mid + 1;
	}

	int i = low;
	for (; i<=high; i++) {
		if (!(a[i] < target))
			break;
	}

	if (a[i] == target)
		return i;
	else
		return -1*(i+1);
}

// Assembly:
decl %esi
xorl %ecx, %ecx
movl %esi, %r9d
subl %ecx, %r9d
cmpl $0x4, %r9d
jle 0x5820
shrl %r9d
addl %ecx, %r9d
movl (%rdi,%r9,4), %r8d
cmpl %edx, %r8d
jne 0x580a
movl %r9d, %eax
jmp 0x581a
ja 0x5814
incl %r9d
movl %r9d, %ecx
jmp 0x581a
decl %r9d
movl %r9d, %esi
cmpl %edx, %r8d
jne 0x57ea
retq
cmpl %ecx, %esi
jl 0x583c
movl %ecx, %eax
incl %esi
leaq (%rdi,%rax,4), %rax
cmpl %edx, (%rax)
jae 0x583c
incl %ecx
addq $0x4, %rax
cmpl %ecx, %esi
jne 0x582c
movl %esi, %ecx
movslq %ecx, %rax
xorl %ecx, %ecx
cmpl %edx, (%rdi,%rax,4)
setne %cl
negl %ecx
xorl %ecx, %eax
retq
// File: /workspace/github_cpp_makefile_star2_O1/kdungs[P]codecon/src/rugby.cc
// Function: main
int main() {
  int score;
  std::cin >> score;

  for (auto co = 0; co <= score / 7; ++co) {
    const auto afterCo = score - 7 * co;
    for (auto tr = 0; tr <= afterCo / 3; ++tr) {
      const auto afterTr = afterCo - 3 * tr;
      if (afterTr % 2 == 0) {
        auto ki = afterTr / 2;
        std::cout << co << ' ' << tr << ' ' << ki << '\n';
      }
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq 0x2e1f(%rip), %rdi      # 0x3fe0
leaq 0x14(%rsp), %rbx
movq %rbx, %rsi
callq 0x1030
movl (%rbx), %r14d
cmpl $-0x6, %r14d
jl 0x12d4
movl $0x0, 0x10(%rsp)
movb $0x20, %r12b
xorl %r13d, %r13d
leal (,%r13,8), %ecx
movl %r13d, %eax
subl %ecx, %eax
addl %r14d, %eax
cmpl $-0x2, %eax
jl 0x12a2
cltq
imulq $0x55555556, %rax, %rax # imm = 0x55555556
movq %rax, %rcx
shrq $0x20, %rcx
shrq $0x3f, %rax
leal (%rcx,%rax), %r15d
incl %r15d
addl 0x10(%rsp), %r14d
xorl %ebp, %ebp
testb $0x1, %r14b
jne 0x1297
movl %r14d, %ebx
sarl %ebx
movq 0x2d9a(%rip), %rdi      # 0x3fd0
movl %r13d, %esi
callq 0x1070
movb %r12b, 0xd(%rsp)
movl $0x1, %edx
movq %rax, %rdi
leaq 0xd(%rsp), %rsi
callq 0x1050
movq %rax, %rdi
movl %ebp, %esi
callq 0x1070
movb %r12b, 0xe(%rsp)
movl $0x1, %edx
movq %rax, %rdi
leaq 0xe(%rsp), %rsi
callq 0x1050
movq %rax, %rdi
movl %ebx, %esi
callq 0x1070
movb $0xa, 0xf(%rsp)
movl $0x1, %edx
movq %rax, %rdi
leaq 0xf(%rsp), %rsi
callq 0x1050
incl %ebp
addl $-0x3, %r14d
cmpl %ebp, %r15d
jne 0x1224
leal 0x1(%r13), %eax
movslq 0x14(%rsp), %r14
imulq $-0x6db6db6d, %r14, %rcx # imm = 0x92492493
shrq $0x20, %rcx
addl %r14d, %ecx
movl %ecx, %edx
shrl $0x1f, %edx
sarl $0x2, %ecx
addl %edx, %ecx
addl $-0x7, 0x10(%rsp)
cmpl %ecx, %r13d
movl %eax, %r13d
jl 0x11e9
xorl %eax, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/louisabraham[P]cage/./cage.hpp
// Function: luby(int)
long long luby(int x)
{
    // Find the finite subsequence that contains index 'x', and the
    // size of that subsequence:
    int size, seq;
    for (size = 1, seq = 0; size < x + 1; seq++, size = 2 * size + 1)
        ;

    while (size - 1 != x)
    {
        size = (size - 1) >> 1;
        seq--;
        x = x % size;
    }

    return 1LL << seq;
}

// Assembly:
movl %edi, %edx
testl %edi, %edi
jle 0x12ec
movl $0x1, %eax
xorl %ecx, %ecx
incl %ecx
movl %eax, %esi
addl %eax, %esi
leal 0x1(,%rax,2), %eax
cmpl %edx, %esi
jl 0x12d9
jmp 0x12fd
xorl %esi, %esi
xorl %ecx, %ecx
jmp 0x12fd
sarl %esi
decl %ecx
movl %edx, %eax
cltd
idivl %esi
decl %esi
cmpl %edx, %esi
jne 0x12f2
movl $0x1, %eax
shlq %cl, %rax
retq
// File: /workspace/github_cpp_makefile_star2_O1/navrajsaini[P]PL_Compiler_design_project/token.cpp
// Function: operator<<(std::ostream&, Token&)
ostream& operator<< (ostream &os, Token& a)
{
   os << "Token: " << spellS(a.getSymbol()) << endl
      << "\tAttributes: " << endl
      << "\t\tLexeme: " << a.getLexeme() << endl
      << "\t\tValue: " << a.getValue() << endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r14
leaq 0xec50(%rip), %rsi      # 0x13383
movl $0x7, %edx
callq 0x2210
movl 0x28(%rbx), %esi
leaq -0x58(%rbp), %r15
movq %r15, %rdi
callq 0x4378
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %r14, %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
movq %rax, %r14
leaq 0xebfc(%rip), %rsi      # 0x1338b
movl $0xd, %edx
movq %rax, %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 %rax, %r14
leaq 0xebcc(%rip), %rsi      # 0x13399
movl $0xa, %edx
movq %rax, %rdi
callq 0x2210
leaq -0x28(%rbp), %r15
movq %r15, -0x10(%r15)
movq 0x8(%rbx), %rsi
movq 0x10(%rbx), %rdx
addq %rsi, %rdx
leaq -0x38(%rbp), %rdi
callq 0x4242
movq -0x38(%rbp), %rsi
movq -0x30(%rbp), %rdx
movq %r14, %rdi
callq 0x2210
movq %rax, %rdi
callq 0x20e0
movq %rax, %r14
leaq 0xeb8c(%rip), %rsi      # 0x133a4
movl $0x9, %edx
movq %rax, %rdi
callq 0x2210
movl (%rbx), %esi
movq %r14, %rdi
callq 0x22f0
movq %rax, %rdi
callq 0x20e0
leaq -0x38(%rbp), %rdi
callq 0x20c0
leaq -0x58(%rbp), %rdi
callq 0x20c0
movq %rax, %rbx
movq -0x38(%rbp), %rdi
cmpq %r15, %rdi
je 0x4861
callq 0x21b0
jmp 0x4861
jmp 0x485e
movq %rax, %rbx
leaq -0x48(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x4873
callq 0x21b0
movq %rbx, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O1/navrajsaini[P]PL_Compiler_design_project/symboltable.cpp
// Function: Symtable::search(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int Symtable::search(string s)
{
   Token a;
   string comp;
   for (/*std::size_t*/int i = 0; i < 307; i++)//check all the loctions that are
      //occupied
   {
      a = htable[i];
      comp = a.getLexeme();
      if ( spellS (a.getSymbol()) != "NONAME")
      {
	 if ( comp == s )
	 {
	    return i;//if found return it's location
	 }
	 else
	    ;
      }
      else
	 ;
   }
   return -1;//return -1 if not found
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rsi, -0x30(%rbp)
movq %rdi, -0x40(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x9d02
leaq -0x58(%rbp), %rax
movq %rax, -0x10(%rax)
movq $0x0, -0x8(%rax)
movb $0x0, (%rax)
leaq -0xa8(%rbp), %r13
xorl %r15d, %r15d
leaq -0xb8(%rbp), %rbx
xorl %ecx, %ecx
xorl %r12d, %r12d
movq %r12, -0x38(%rbp)
movq %rcx, -0x48(%rbp)
movq -0x40(%rbp), %rax
movq (%rax), %r12
leaq (%r12,%r15), %rsi
addq $0x8, %rsi
movl -0x8(%rsi), %eax
movl %eax, -0x98(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x2100
movl 0x28(%r12,%r15), %eax
movl %eax, -0x70(%rbp)
movq %r13, %r12
movq %r13, -0xb8(%rbp)
movq -0x90(%rbp), %rsi
movq -0x88(%rbp), %rdx
addq %rsi, %rdx
movq %rbx, %r14
movq %rbx, %rdi
callq 0x4242
leaq -0x68(%rbp), %rdi
movq %r14, %rsi
callq 0x2240
movq -0xb8(%rbp), %rdi
cmpq %r12, %rdi
je 0x9698
callq 0x21b0
movl -0x70(%rbp), %esi
movq %rbx, %r14
movq %rbx, %rdi
callq 0x4378
movq %r14, %rdi
leaq 0x9c51(%rip), %rsi      # 0x13301
callq 0x2080
movl %eax, %r12d
movq -0xb8(%rbp), %rdi
cmpq %r13, %rdi
je 0x96c9
callq 0x21b0
testl %r12d, %r12d
movq -0x48(%rbp), %r14
je 0x96f9
movq -0x60(%rbp), %rdx
movq -0x30(%rbp), %rax
cmpq 0x8(%rax), %rdx
jne 0x96f9
testq %rdx, %rdx
je 0x9723
movq -0x30(%rbp), %rax
movq (%rax), %rsi
movq -0x68(%rbp), %rdi
callq 0x21e0
testl %eax, %eax
je 0x9723
cmpq $0x132, %r14            # imm = 0x132
leaq 0x1(%r14), %rax
setae %r12b
addq $0x30, %r15
movq %rax, %rcx
cmpq $0x133, %rax            # imm = 0x133
jne 0x9621
movl $0x133, %r14d           # imm = 0x133
jmp 0x9727
movq -0x38(%rbp), %r12
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x9739
callq 0x21b0
leaq -0x80(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x974b
callq 0x21b0
testb $0x1, %r12b
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmovnel %eax, %r14d
movl %r14d, %eax
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x9771
jmp 0x9771
movq %rax, %rbx
movq -0x68(%rbp), %rdi
leaq -0x58(%rbp), %rax
cmpq %rax, %rdi
je 0x9786
callq 0x21b0
leaq -0x80(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9798
callq 0x21b0
movq %rbx, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O1/navrajsaini[P]PL_Compiler_design_project/symboltable.cpp
// Function: Symtable::printTable()
void Symtable::printTable()
{
   Token a;
   for (std::size_t i = 0; i < 307; i++)
   {
      a = htable[i];
      if (spellS (a.getSymbol()) != "NONAME")
      {
	 cout << a;
      }
   }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
leaq -0x58(%rbp), %rdi
callq 0x9d02
movl $0x28, %r15d
leaq -0x78(%rbp), %r12
leaq 0x9b05(%rip), %r13      # 0x13301
movq (%rbx), %r14
leaq (%r14,%r15), %rsi
addq $-0x20, %rsi
movl -0x8(%rsi), %eax
movl %eax, -0x58(%rbp)
leaq -0x50(%rbp), %rdi
callq 0x2100
movl (%r14,%r15), %esi
movl %esi, -0x30(%rbp)
movq %r12, %rdi
callq 0x4378
movq %r12, %rdi
movq %r13, %rsi
callq 0x2080
movl %eax, %r14d
movq -0x78(%rbp), %rdi
leaq -0x68(%rbp), %rax
cmpq %rax, %rdi
je 0x9845
callq 0x21b0
testl %r14d, %r14d
je 0x985a
movq 0xf777(%rip), %rdi      # 0x18fc8
leaq -0x58(%rbp), %rsi
callq 0x4719
addq $0x30, %r15
cmpq $0x39b8, %r15           # imm = 0x39B8
jne 0x97fc
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x9879
callq 0x21b0
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x988a
movq %rax, %rbx
leaq -0x40(%rbp), %rax
movq -0x10(%rax), %rdi
cmpq %rax, %rdi
je 0x989f
callq 0x21b0
movq %rbx, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O1/navrajsaini[P]PL_Compiler_design_project/administration.cpp
// Function: Admin::Admin(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, Scanner&)
Admin::Admin(string inFile, string outFile, Scanner &sn)
{
   output.open(outFile.c_str());
   output.close();
   in = inFile;
   out = outFile;
   //scnr = &scan;
   view.setName(in, out);
   view.symbolTable.loadResvd();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rdx, %r13
movq %rsi, %rbx
movq %rdi, %r15
movw $0x101, (%rdi)          # imm = 0x101
movb $0x0, 0x2(%rdi)
addq $0x8, %rdi
movq %rdi, -0x68(%rbp)
callq 0x2200
leaq 0x210(%r15), %r14
movq %r14, %rdi
callq 0x22e0
leaq 0x410(%r15), %r12
movq %r12, %rdi
callq 0x22e0
movq %r12, -0x60(%rbp)
leaq 0x610(%r15), %rax
movq %rax, -0x38(%rbp)
leaq 0x620(%r15), %rax
movq %rax, -0x58(%rbp)
movq %rax, 0x610(%r15)
xorl %eax, %eax
movq %rax, 0x618(%r15)
movb %al, 0x620(%r15)
leaq 0x630(%r15), %rcx
movq %rcx, -0x30(%rbp)
leaq 0x640(%r15), %rcx
movq %rcx, -0x50(%rbp)
movq %rcx, 0x630(%r15)
movq %rax, 0x638(%r15)
movb %al, 0x640(%r15)
leaq 0x650(%r15), %rdi
leaq 0x660(%r15), %rax
movq %rax, -0x40(%rbp)
movq %rax, 0x650(%r15)
leaq 0x8d65(%rip), %rsi      # 0x1313e
leaq 0x8d66(%rip), %rdx      # 0x13146
movq %rdi, -0x48(%rbp)
callq 0x42dc
leaq 0x670(%r15), %r12
movq %r12, %rdi
callq 0xacb4
movq (%r13), %rsi
movq %r14, %rdi
movl $0x10, %edx
callq 0x2040
movq %r14, %rdi
callq 0x2270
movq -0x38(%rbp), %rdi
movq %rbx, %rsi
callq 0x2100
movq -0x30(%rbp), %rdi
movq %r13, %rsi
callq 0x2100
leaq -0x98(%rbp), %rbx
movq %rbx, -0x10(%rbx)
movq 0x610(%r15), %rsi
movq 0x618(%r15), %rdx
addq %rsi, %rdx
leaq -0xa8(%rbp), %rdi
callq 0x4242
leaq -0x78(%rbp), %r13
movq %r13, -0x10(%r13)
movq 0x630(%r15), %rsi
movq 0x638(%r15), %rdx
addq %rsi, %rdx
leaq -0x88(%rbp), %rdi
callq 0x4242
leaq -0xa8(%rbp), %rsi
leaq -0x88(%rbp), %rdx
movq %r12, %rdi
callq 0xb154
movq -0x88(%rbp), %rdi
cmpq %r13, %rdi
je 0xa49d
callq 0x21b0
movq -0xa8(%rbp), %rdi
cmpq %rbx, %rdi
je 0xa4ae
callq 0x21b0
addq $0x678, %r15            # imm = 0x678
movq %r15, %rdi
callq 0x487c
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r15
movq -0x88(%rbp), %rdi
cmpq %r13, %rdi
je 0xa4e8
callq 0x21b0
jmp 0xa4e8
movq %rax, %r15
movq -0xa8(%rbp), %rdi
cmpq %rbx, %rdi
je 0xa512
callq 0x21b0
jmp 0xa512
movq %rax, %r15
jmp 0xa51a
movq %rax, %r15
jmp 0xa52c
movq %rax, %r15
jmp 0xa559
movq %rax, %r15
jmp 0xa561
movq %rax, %r15
movq %r12, %rdi
callq 0x416e
movq -0x48(%rbp), %rax
movq (%rax), %rdi
cmpq -0x40(%rbp), %rdi
je 0xa52c
callq 0x21b0
movq -0x30(%rbp), %rax
movq (%rax), %rdi
cmpq -0x50(%rbp), %rdi
je 0xa53e
callq 0x21b0
movq -0x38(%rbp), %rax
movq (%rax), %rdi
cmpq -0x58(%rbp), %rdi
je 0xa550
callq 0x21b0
movq -0x60(%rbp), %rdi
callq 0x2290
movq %r14, %rdi
callq 0x2290
movq -0x68(%rbp), %rdi
callq 0x2060
movq %r15, %rdi
callq 0x2310
// File: /workspace/github_cpp_makefile_star2_O1/navrajsaini[P]PL_Compiler_design_project/administration.cpp
// Function: Admin::scan()
int Admin::scan()
{
   char now[256];
   input.open(in.c_str());
   do{
      //clearing the array of characters
      for(int j=0;j<255;j++)
	 now[j]=' ';  
      input.getline(now,256);   
      view.tokenLine(now, 256);
      view.LN++;
      lineNo++;
   }while(!input.eof());
/*
  for debuging purposes
  view.symbolTable.printTable();
  
*/
input.close();
   return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x100, %rsp            # imm = 0x100
movq %rdi, %r14
leaq 0x8(%rdi), %rbx
movq 0x610(%rdi), %rsi
movq %rbx, %rdi
movl $0x8, %edx
callq 0x2130
leaq 0x670(%r14), %r15
leaq -0x120(%rbp), %r12
movl $0xff, %edx
movq %r12, %rdi
movl $0x20, %esi
callq 0x2110
movq 0x8(%r14), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %ecx
movl $0x100, %edx            # imm = 0x100
movq %rbx, %rdi
movq %r12, %rsi
callq 0x2350
movq %r15, %rdi
movq %r12, %rsi
movl $0x100, %edx            # imm = 0x100
callq 0xb39c
incl 0x1298(%r14)
incl 0x1ce0(%r14)
movq 0x8(%r14), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x28(%r14,%rax)
je 0xa5eb
movq %rbx, %rdi
callq 0x2050
movl $0x1, %eax
addq $0x100, %rsp            # imm = 0x100
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/navrajsaini[P]PL_Compiler_design_project/administration.cpp
// Function: Admin::emit1(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Admin::emit1(string OP)
{
   outsource.open(codeGen, ios::app);
   
   if (emitting)
   {
      outsource << OP << endl;
   }
   outsource.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
leaq 0x410(%rdi), %rbx
leaq 0x650(%rdi), %rsi
movq %rbx, %rdi
movl $0x1, %edx
callq 0x20d0
cmpb $0x1, (%r15)
jne 0xaaf2
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %rbx, %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
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x2270
// File: /workspace/github_cpp_makefile_star2_O1/navrajsaini[P]PL_Compiler_design_project/administration.cpp
// Function: Admin::emit2(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
void Admin::emit2 (string OP, int arg1)
{
   outsource.open(codeGen, ios::app);
   if (emitting)
   {
      outsource << OP << endl << arg1 << endl;
   }
   outsource.close();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %r14d
movq %rsi, %r15
movq %rdi, %r12
leaq 0x410(%rdi), %rbx
leaq 0x650(%rdi), %rsi
movq %rbx, %rdi
movl $0x1, %edx
callq 0x20d0
cmpb $0x1, (%r12)
jne 0xaba8
movq (%r15), %rsi
movq 0x8(%r15), %rdx
movq %rbx, %rdi
callq 0x2210
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2140
movq %rax, %rdi
movl %r14d, %esi
callq 0x22f0
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
movq %rbx, %rdi
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x2270
// File: /workspace/github_cpp_makefile_star2_O1/navrajsaini[P]PL_Compiler_design_project/administration.cpp
// Function: Admin::emit3(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int, int)
void Admin::emit3 (string OP, int arg1, int arg2)
{
   outsource.open(codeGen, ios::app);
   if (emitting)
   {
      outsource << OP << endl << arg1 << endl << arg2 << endl;
   }
   outsource.close();
   
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %r14d
movl %edx, %r15d
movq %rsi, %r12
movq %rdi, %r13
leaq 0x410(%rdi), %rbx
leaq 0x650(%rdi), %rsi
movq %rbx, %rdi
movl $0x1, %edx
callq 0x20d0
cmpb $0x1, (%r13)
jne 0xac9d
movq (%r12), %rsi
movq 0x8(%r12), %rdx
movq %rbx, %rdi
callq 0x2210
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
movq %rax, %rdi
movl %r15d, %esi
callq 0x22f0
movq %rax, %r15
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %r15, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2140
movq %rax, %rdi
movl %r14d, %esi
callq 0x22f0
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
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2270
nop
// File: /workspace/github_cpp_makefile_star2_O1/navrajsaini[P]PL_Compiler_design_project/scanner.cpp
// Function: Scanner::Scanner(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
Scanner::Scanner(string inCodeName, string outCodeName)//, Symtable &symbolTable)
{
   setName(inCodeName, outCodeName);
   symbolTable.loadResvd();
   LN=1;
   TN=1;
   while(TN<255)
   {
      lineToke[TN][0] = 0;
      lineToke[TN][1] = 0;
      lineToke[TN][2] = 0;
      TN++;
   }
   TN=1;
	 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
leaq 0x8(%rdi), %rbx
leaq -0x29(%rbp), %rdx
movl $0x133, %esi            # imm = 0x133
movq %rbx, %rdi
callq 0xae30
movl $0x0, 0x20(%r12)
movl $0x1, 0xc2c(%r12)
leaq 0xc30(%r12), %rdi
movq %rdi, -0x58(%rbp)
callq 0x22e0
leaq 0xe30(%r12), %rax
movq %rax, -0x40(%rbp)
leaq 0xe40(%r12), %rax
movq %rax, -0x50(%rbp)
movq %rax, 0xe30(%r12)
xorl %eax, %eax
movq %rax, 0xe38(%r12)
movb %al, 0xe40(%r12)
leaq 0xe50(%r12), %rcx
movq %rcx, -0x38(%rbp)
leaq 0xe60(%r12), %rcx
movq %rcx, -0x48(%rbp)
movq %rcx, 0xe50(%r12)
movq %rax, 0xe58(%r12)
movb %al, 0xe60(%r12)
leaq -0x88(%rbp), %r13
movq %r13, -0x10(%r13)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq -0x98(%rbp), %rdi
callq 0x4242
leaq -0x68(%rbp), %r15
movq %r15, -0x10(%r15)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq -0x78(%rbp), %rdi
callq 0x4242
leaq -0x98(%rbp), %rsi
movq -0x40(%rbp), %rdi
callq 0x2100
leaq -0x78(%rbp), %rsi
movq -0x38(%rbp), %rdi
callq 0x2100
movq -0x78(%rbp), %rdi
cmpq %r15, %rdi
je 0xb05e
callq 0x21b0
movq -0x98(%rbp), %rdi
cmpq %r13, %rdi
je 0xb06f
callq 0x21b0
movq %rbx, %rdi
callq 0x487c
movabsq $0x100000001, %rax      # imm = 0x100000001
movq %rax, 0xc28(%r12)
leaq 0x28(%r12), %rax
movl $0x1, %ecx
movslq %ecx, %rcx
leaq (%rcx,%rcx,2), %rcx
movq $0x0, (%rax,%rcx,4)
movslq 0xc2c(%r12), %rdx
leaq (%rdx,%rdx,2), %rcx
movl $0x0, 0x8(%rax,%rcx,4)
leal 0x1(%rdx), %ecx
movl %ecx, 0xc2c(%r12)
cmpq $0xfe, %rdx
jl 0xb093
movl $0x1, 0xc2c(%r12)
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r12
jmp 0xb100
movq %rax, %r12
jmp 0xb143
movq %rax, %r12
movq -0x78(%rbp), %rdi
cmpq %r15, %rdi
je 0xb100
callq 0x21b0
movq -0x98(%rbp), %rdi
cmpq %r13, %rdi
je 0xb116
callq 0x21b0
jmp 0xb116
movq %rax, %r12
movq -0x38(%rbp), %rax
movq (%rax), %rdi
cmpq -0x48(%rbp), %rdi
je 0xb128
callq 0x21b0
movq -0x40(%rbp), %rax
movq (%rax), %rdi
cmpq -0x50(%rbp), %rdi
je 0xb13a
callq 0x21b0
movq -0x58(%rbp), %rdi
callq 0x2290
movq %rbx, %rdi
callq 0x41f2
movq %r12, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O1/navrajsaini[P]PL_Compiler_design_project/scanner.cpp
// Function: Scanner::inc(int)
void Scanner::inc(int SV)
{
lineToke[TN][1] = SV;
lineToke[TN][0] = LN;
lineToke[TN][2] = 0;
//cout<<TN
TN++;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movslq 0xc2c(%rdi), %rax
leaq (%rax,%rax,2), %rax
movl %esi, 0x2c(%rdi,%rax,4)
movl 0xc28(%rdi), %eax
movslq 0xc2c(%rdi), %rcx
leaq (%rcx,%rcx,2), %rdx
movl %eax, 0x28(%rdi,%rdx,4)
movl $0x0, 0x30(%rdi,%rdx,4)
leal 0x1(%rcx), %eax
movl %eax, 0xc2c(%rdi)
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/navrajsaini[P]PL_Compiler_design_project/scanner.cpp
// Function: Scanner::getToken(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int Scanner::getToken(string token)
{
   int storeVal;
   
   storeVal = symbolTable.insert(token);

   inc(storeVal);

   
   return storeVal;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq -0x40(%rbp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x4242
movq %r14, %rdi
movq %r15, %rsi
callq 0x4ff2
movl %eax, %r14d
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0xb288
callq 0x21b0
movslq 0xc2c(%rbx), %rax
leaq (%rax,%rax,2), %rax
movl %r14d, 0x2c(%rbx,%rax,4)
movl 0xc28(%rbx), %eax
movslq 0xc2c(%rbx), %rcx
leaq (%rcx,%rcx,2), %rdx
movl %eax, 0x28(%rbx,%rdx,4)
movl $0x0, 0x30(%rbx,%rdx,4)
leal 0x1(%rcx), %eax
movl %eax, 0xc2c(%rbx)
movl %r14d, %eax
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 0xb2df
callq 0x21b0
movq %rbx, %rdi
callq 0x2310
nop
// File: /workspace/github_cpp_makefile_star2_O1/navrajsaini[P]PL_Compiler_design_project/scanner.cpp
// Function: Scanner::getNum(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
int Scanner::getNum(string token)
{
   int storeVal;
   storeVal = symbolTable.insertNum(token);
   inc(storeVal);
   return storeVal;
   
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x20, %rsp
movq %rdi, %rbx
leaq 0x8(%rdi), %r14
leaq -0x30(%rbp), %r12
movq %r12, -0x10(%r12)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
addq %rax, %rdx
leaq -0x40(%rbp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x4242
movq %r14, %rdi
movq %r15, %rsi
callq 0x98a8
movl %eax, %r14d
movq -0x40(%rbp), %rdi
cmpq %r12, %rdi
je 0xb33c
callq 0x21b0
movslq 0xc2c(%rbx), %rax
leaq (%rax,%rax,2), %rax
movl %r14d, 0x2c(%rbx,%rax,4)
movl 0xc28(%rbx), %eax
movslq 0xc2c(%rbx), %rcx
leaq (%rcx,%rcx,2), %rdx
movl %eax, 0x28(%rbx,%rdx,4)
movl $0x0, 0x30(%rbx,%rdx,4)
leal 0x1(%rcx), %eax
movl %eax, 0xc2c(%rbx)
movl %r14d, %eax
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 0xb393
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::eraseList()
void Parse::eraseList()
{
   eraseVar();
   for(int i = 0; i <= 10; i++)
   {
      varListIndex[i] = 0;
      varListVal[i] = 0;
      size[i] = 1;
   }
   listDepth = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
movl %eax, 0x4ddc(%rdi)
movabsq $0x400000002, %rcx      # imm = 0x400000002
movq %rcx, 0x4dd4(%rdi)
movabsq $0x100000000, %rcx      # imm = 0x100000000
movq %rcx, 0x4de4(%rdi)
movl %eax, 0x4d88(%rdi)
xorl %ecx, %ecx
movl %eax, 0x4d38(%rdi,%rcx,4)
movl %eax, 0x4d60(%rdi,%rcx,4)
movl $0x1, 0x4de8(%rdi,%rcx,4)
incq %rcx
cmpq $0xb, %rcx
jne 0xbf5e
movl $0x0, 0x4d88(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::match()
void Parse::match()
{
   NS=LHS;
   LHS=token[tokeNum];
   tokeNum++;
   //test line
   //cout<<"token '"<<LHS<<"' is the '"<<tokeNum-1<<"' token parsed"<<endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
leaq 0x5050(%rdi), %r14
addq $0x5070, %rdi           # imm = 0x5070
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
nop
// File: /workspace/github_cpp_makefile_star2_O1/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::parseNow()
void Parse::parseNow()
{  //test line
   //printToken();
   //o();
   //LHS = token[tokeNum];
   for(int i = 0; i<10; i++)
      valLength[i] = 0;
   NS=LHS;
   //cout<<endl<<LHS<<endl;
   Program();
   for(int i = 0; i<10; i++)
      valLength[i] = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x71d4(%rdi)
movups %xmm0, 0x71c4(%rdi)
xorl %r14d, %r14d
movq %r14, 0x71e4(%rdi)
leaq 0x5050(%rdi), %rsi
addq $0x5070, %rdi           # imm = 0x5070
callq 0x2100
movq %rbx, %rdi
callq 0xcc98
movq %r14, 0x71e4(%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x71d4(%rbx)
movups %xmm0, 0x71c4(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::scopeError(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
void Parse::scopeError(string s)
{
   gen.emitting = 0;
   if(stopType == 0)
   {
      isErr = 1;
      cout<<s<<" with index: "<<ln[tokeNum][1]<<" at line:  "<<ln[tokeNum][0]<<" with token : "<<NS<<endl;
      ctd = 0;
   }
}

// Assembly:
movb $0x0, 0x50c0(%rdi)
cmpb $0x0, 0x2c31(%rdi)
je 0xc54d
retq
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movb $0x1, 0x50b8(%rdi)
movq (%rsi), %rax
movq 0x8(%rsi), %rdx
movq 0xca5c(%rip), %rdi      # 0x18fc8
movq %rax, %rsi
callq 0x2210
movq %rax, %r14
leaq 0x709a(%rip), %rsi      # 0x13618
movl $0xd, %edx
movq %rax, %rdi
callq 0x2210
movslq 0x2028(%rbx), %rax
leaq (%rax,%rax,2), %rax
movl 0x2034(%rbx,%rax,4), %esi
movq %r14, %rdi
callq 0x22f0
movq %rax, %r14
leaq 0x7077(%rip), %rsi      # 0x13626
movl $0xb, %edx
movq %rax, %rdi
callq 0x2210
movslq 0x2028(%rbx), %rax
leaq (%rax,%rax,2), %rax
movl 0x2030(%rbx,%rax,4), %esi
movq %r14, %rdi
callq 0x22f0
movq %rax, %r14
leaq 0x7052(%rip), %rsi      # 0x13632
movl $0xe, %edx
movq %rax, %rdi
callq 0x2210
movq 0x5070(%rbx), %rsi
movq 0x5078(%rbx), %rdx
movq %r14, %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, 0x2c30(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::eraseVar()
void Parse::eraseVar()
{
   index = 0;
   eKind = UNDEFINED;
   eType = UNIVERSAL;
   checkVal = 0;
   size[0] = 1;
   listDepth = 0;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %eax, %eax
movl %eax, 0x4ddc(%rdi)
movabsq $0x400000002, %rcx      # imm = 0x400000002
movq %rcx, 0x4dd4(%rdi)
movabsq $0x100000000, %rcx      # imm = 0x100000000
movq %rcx, 0x4de4(%rdi)
movl %eax, 0x4d88(%rdi)
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O1/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::checkDefConst()
bool Parse::checkDefConst()
{//printScopeType(true);
   if (!bTable.define(index, eKind, eType, size[0], checkVal, levelOfCurrentBlock[currentLevel], 0))//proc label and displacement
   {
      eraseVar();
      return false;
   }
   //cout<<endl<<"'"<<levelOfCurrentBlock[currentLevel]<<"'"<<currentLevel<<"'"<<endl;
   levelOfCurrentBlock[currentLevel]++;
   eraseVar();
   return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
addq $0x4c38, %rdi           # imm = 0x4C38
movl 0x4ddc(%rbx), %esi
movl 0x4dd4(%rbx), %ecx
movl 0x4dd8(%rbx), %edx
movl 0x4de8(%rbx), %r8d
movl 0x4de4(%rbx), %r9d
movslq 0x7224(%rbx), %rax
movl 0x71fc(%rbx,%rax,4), %eax
pushq $0x0
pushq %rax
callq 0x104ca
addq $0x10, %rsp
testb %al, %al
je 0xc6cc
movslq 0x7224(%rbx), %rcx
incl 0x71fc(%rbx,%rcx,4)
xorl %ecx, %ecx
movl %ecx, 0x4ddc(%rbx)
movabsq $0x400000002, %rdx      # imm = 0x400000002
movq %rdx, 0x4dd4(%rbx)
movabsq $0x100000000, %rdx      # imm = 0x100000000
movq %rdx, 0x4de4(%rbx)
movl %ecx, 0x4d88(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::checkDef(int)
bool Parse::checkDef(int procLabel)
{//printScopeType(true);
   if (!bTable.define(index, eKind, eType, 0, 0, 0, procLabel))
   {
      eraseVar();
      return false;
   }
   eraseVar();
   return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %eax
movq %rdi, %rbx
addq $0x4c38, %rdi           # imm = 0x4C38
movl 0x4ddc(%rbx), %esi
movl 0x4dd4(%rbx), %ecx
movl 0x4dd8(%rbx), %edx
xorl %r14d, %r14d
xorl %r8d, %r8d
xorl %r9d, %r9d
pushq %rax
pushq %r14
callq 0x104ca
addq $0x10, %rsp
movl %r14d, 0x4ddc(%rbx)
movabsq $0x400000002, %rcx      # imm = 0x400000002
movq %rcx, 0x4dd4(%rbx)
movabsq $0x100000000, %rcx      # imm = 0x100000000
movq %rcx, 0x4de4(%rbx)
movl %r14d, 0x4d88(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::checkDefList()
bool Parse::checkDefList()
{//printScopeType(false);
   
   for(int limit = 0; limit < listDepth; limit++)
   {
      
      if (!bTable.define(varListIndex[limit], eKind, eType, size[limit], varListVal[limit],levelOfCurrentBlock[currentLevel], 0))//incriment displacment by 1
      {
	 eraseList();
	 return false;
      }
      //cout<<endl<<"'"<<levelOfCurrentBlock[currentLevel]<<"'"<<currentLevel<<"'"<<endl;
      levelOfCurrentBlock[currentLevel]++;
   }
   eraseList();
   return true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, 0x4d88(%rdi)
setle %r14b
movabsq $0x400000002, %r13      # imm = 0x400000002
jle 0xc810
leaq 0x4c38(%rbx), %r15
xorl %r12d, %r12d
movl 0x4dd4(%rbx), %ecx
movl 0x4dd8(%rbx), %edx
movl 0x4de8(%rbx,%r12,4), %r8d
movl 0x4d38(%rbx,%r12,4), %esi
movl 0x4d60(%rbx,%r12,4), %r9d
movslq 0x7224(%rbx), %rax
movl 0x71fc(%rbx,%rax,4), %eax
movq %r15, %rdi
pushq $0x0
pushq %rax
callq 0x104ca
addq $0x10, %rsp
testb %al, %al
je 0xc87d
movslq 0x7224(%rbx), %rax
incl 0x71fc(%rbx,%rax,4)
incq %r12
movslq 0x4d88(%rbx), %rax
cmpq %rax, %r12
setge %r14b
jl 0xc7a6
leaq 0x4d88(%rbx), %rax
movabsq $0x100000000, %rsi      # imm = 0x100000000
xorl %ecx, %ecx
movl %ecx, 0x4ddc(%rbx)
movq %r13, 0x4dd4(%rbx)
movq %rsi, 0x4de4(%rbx)
movl %ecx, 0x4d88(%rbx)
xorl %edx, %edx
movl %ecx, 0x4d38(%rbx,%rdx,4)
movl %ecx, 0x4d60(%rbx,%rdx,4)
movl $0x1, 0x4de8(%rbx,%rdx,4)
incq %rdx
cmpq $0xb, %rdx
jne 0xc83f
movl $0x0, (%rax)
andb $0x1, %r14b
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x4d88(%rbx), %rax
xorl %ecx, %ecx
movl %ecx, 0x4ddc(%rbx)
movq %r13, 0x4dd4(%rbx)
movabsq $0x100000000, %rsi      # imm = 0x100000000
movq %rsi, 0x4de4(%rbx)
movl %ecx, 0x4d88(%rbx)
xorl %edx, %edx
movl %ecx, 0x4d38(%rbx,%rdx,4)
movl %ecx, 0x4d60(%rbx,%rdx,4)
movl $0x1, 0x4de8(%rbx,%rdx,4)
incq %rdx
cmpq $0xb, %rdx
jne 0xc8ac
movl $0x0, (%rax)
testb $0x1, %r14b
jne 0xc821
jmp 0xc867
// File: /workspace/github_cpp_makefile_star2_O1/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::printScopeType(bool)
void Parse::printScopeType(bool y)
{
   if(y)
      cout<<"index: "<<index<<" "<<NS<<endl<<LHS<<"  "<<ln[tokeNum][1]<<endl;
   if(!y)
      cout<<"indexAc: "<<varListIndex[listDepth-1]<<" "<<endl<<LHS<<"  "<<ln[tokeNum][1]<<endl;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movq 0xc6d7(%rip), %r14      # 0x18fc8
testl %esi, %esi
je 0xc949
leaq 0x7000(%rip), %rsi      # 0x138fc
movl $0x7, %edx
movq %r14, %rdi
callq 0x2210
movl 0x4ddc(%rbx), %esi
movq %r14, %rdi
callq 0x22f0
movq %rax, %r14
leaq 0x6fec(%rip), %rsi      # 0x1390d
movl $0x1, %edx
movq %rax, %rdi
callq 0x2210
movq 0x5070(%rbx), %rsi
movq 0x5078(%rbx), %rdx
movq %r14, %rdi
callq 0x2210
movq %rax, %r14
jmp 0xc98a
leaq 0x6cf1(%rip), %rsi      # 0x13641
movl $0x9, %edx
movq %r14, %rdi
callq 0x2210
movslq 0x4d88(%rbx), %rax
movl 0x4d34(%rbx,%rax,4), %esi
movq %r14, %rdi
callq 0x22f0
movq %rax, %r14
leaq 0x6f90(%rip), %rsi      # 0x1390d
movl $0x1, %edx
movq %rax, %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 0x5050(%rbx), %rsi
movq 0x5058(%rbx), %rdx
movq %rax, %rdi
callq 0x2210
movq %rax, %r14
leaq 0x6f3b(%rip), %rsi      # 0x1390c
movl $0x2, %edx
movq %rax, %rdi
callq 0x2210
movslq 0x2028(%rbx), %rax
leaq (%rax,%rax,2), %rax
movl 0x2034(%rbx,%rax,4), %esi
movq %r14, %rdi
callq 0x22f0
movq %rax, %rbx
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x2030
movq %rax, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x2140
// File: /workspace/github_cpp_makefile_star2_O1/navrajsaini[P]PL_Compiler_design_project/parser.cpp
// Function: Parse::o()
void Parse::o()
{ for(int i=1;token[i]!=".";i++)
   {
      cout<<"ln["<<i<<"][0]: "<<ln[i][0]<<endl;
      cout<<"ln["<<i<<"][1]: "<<ln[i][1]<<endl;
      cout<<"ln["<<i<<"][2]: "<<ln[i][2]<<endl;
      cout<<"token["<<i<<"]: "<<token[i]<<endl<<endl;
   }

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x20(%rdi), %r14
leaq 0x6fcd(%rip), %rsi      # 0x13a0f
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xcc6d
addq $0x2044, %rbx           # imm = 0x2044
movl $0x1, %r15d
movl $0x3, %edx
movq 0xc55d(%rip), %r13      # 0x18fc8
movq %r13, %rdi
leaq 0x6bd6(%rip), %r12      # 0x1364b
movq %r12, %rsi
callq 0x2210
movq %r13, %rdi
movl %r15d, %esi
callq 0x22f0
movq %rax, %r13
movl $0x6, %edx
movq %rax, %rdi
leaq 0x6bb5(%rip), %rsi      # 0x1364f
callq 0x2210
movl -0x8(%rbx), %esi
movq %r13, %rdi
callq 0x22f0
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %r13, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2140
movl $0x3, %edx
movq 0xc4e8(%rip), %r13      # 0x18fc8
movq %r13, %rdi
movq %r12, %rsi
callq 0x2210
movq %r13, %rdi
movl %r15d, %esi
callq 0x22f0
movq %rax, %r13
movl $0x6, %edx
movq %rax, %rdi
leaq 0x6b4e(%rip), %rsi      # 0x13656
callq 0x2210
movl -0x4(%rbx), %esi
movq %r13, %rdi
callq 0x22f0
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %r13, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2140
movl $0x3, %edx
movq 0xc47a(%rip), %r13      # 0x18fc8
movq %r13, %rdi
movq %r12, %rsi
callq 0x2210
movq %r13, %rdi
movq %r13, %r12
movl %r15d, %esi
callq 0x22f0
movq %rax, %r13
movl $0x6, %edx
movq %rax, %rdi
leaq 0x6ae4(%rip), %rsi      # 0x1365d
callq 0x2210
movl (%rbx), %esi
movq %r13, %rdi
callq 0x22f0
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %r13, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2140
movl $0x6, %edx
movq %r12, %rdi
leaq 0x6aa3(%rip), %rsi      # 0x13664
callq 0x2210
movq %r12, %rdi
movl %r15d, %esi
callq 0x22f0
movq %rax, %r13
movl $0x3, %edx
movq %rax, %rdi
leaq 0x6a6f(%rip), %rsi      # 0x13652
callq 0x2210
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r13, %rdi
callq 0x2210
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %r13, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2140
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x21c0
movsbl %al, %esi
movq %r13, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2140
addq $0x20, %r14
movq %r14, %rdi
leaq 0x6db6(%rip), %rsi      # 0x13a0f
callq 0x2080
addq $0xc, %rbx
incl %r15d
testl %eax, %eax
jne 0xca5f
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::Block()
void Parse::Block()
{where="B";check();
   //local variable for code gen
   int sLabel = startLabel ,vLabel = varLabel;
   
   if(LHS=="begin")
   {

      
      
      match();
      //call defptr then stat ptr
      DefPtr();
      //
      gen.emit3("DEFARG", vLabel, valLength[valLenPtr]);
      gen.emit2("DEFADDR", sLabel);
      //***
      
      StatPtr();
      
      if(LHS=="end")
      {
	 valLength[valLenPtr] = 0;
	 match();
	 
      }else
	 errorReport();
   }else
      errorReport();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdi, %rbx
addq $0x5098, %rdi           # imm = 0x5098
movq 0x50a0(%rbx), %rdx
leaq 0x6985(%rip), %rcx      # 0x138e0
movl $0x1, %r8d
xorl %esi, %esi
callq 0x22b0
movq %rbx, %rdi
callq 0xc41a
movl 0x71bc(%rbx), %r13d
movl 0x71c0(%rbx), %r15d
leaq 0x5050(%rbx), %r14
leaq 0x639c(%rip), %rsi      # 0x13328
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xcfae
movq %rbx, %rdi
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xc1be
movl %r15d, -0x2c(%rbp)
leaq 0x5070(%rbx), %rdi
movq %rdi, -0x38(%rbp)
movq %r14, %rsi
callq 0x2100
movslq 0x2028(%rbx), %rsi
shlq $0x5, %rsi
addq %rbx, %rsi
movq %r14, %rdi
callq 0x2100
incl 0x2028(%rbx)
movq %rbx, %rdi
callq 0xd118
leaq 0x50c0(%rbx), %r15
leaq -0x48(%rbp), %rax
movq %rax, -0x10(%rax)
leaq 0x66ad(%rip), %rsi      # 0x136ac
leaq 0x66ac(%rip), %rdx      # 0x136b2
leaq -0x58(%rbp), %r12
movq %r12, %rdi
callq 0x42dc
movslq 0x71ec(%rbx), %rax
movl 0x71c4(%rbx,%rax,4), %ecx
movq %r15, %rdi
movq %r12, %rsi
movl %r13d, %edx
callq 0xabb8
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0xd040
callq 0x21b0
leaq -0x68(%rbp), %r13
movq %r13, -0x10(%r13)
leaq 0x6664(%rip), %rsi      # 0x136b3
leaq 0x6664(%rip), %rdx      # 0x136ba
leaq -0x78(%rbp), %r12
movq %r12, %rdi
callq 0x42dc
movq %r15, %rdi
movq %r12, %rsi
movl -0x2c(%rbp), %edx
callq 0xab04
movq -0x78(%rbp), %rdi
cmpq %r13, %rdi
je 0xd07e
callq 0x21b0
movq %rbx, %rdi
callq 0xd246
leaq 0x62a1(%rip), %rsi      # 0x1332e
movq %r14, %rdi
callq 0x2080
testl %eax, %eax
je 0xd0a3
movq %rbx, %rdi
callq 0xc1be
jmp 0xd0dd
movslq 0x71ec(%rbx), %rax
movl $0x0, 0x71c4(%rbx,%rax,4)
movq -0x38(%rbp), %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 $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq -0x78(%rbp), %rdi
cmpq %r13, %rdi
jne 0xd10a
jmp 0xd10f
movq %rax, %rbx
movq -0x58(%rbp), %rdi
leaq -0x48(%rbp), %rax
cmpq %rax, %rdi
je 0xd10f
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::DefPtr()
void Parse::DefPtr()
{where="DP";check();
// local code gen vars
   int varLength = 0;
   
   
   if(LHS=="const"||LHS=="integer"||LHS=="boolean"||LHS=="proc"||LHS=="Boolean")
   {  //calling def
      Def();
      
      
      if(LHS==";")
      {
	 match();
	 
	 DefPtr();
       
      }else if(LHS==".")
      {
      }else	 
	 errorReport();
   }  
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x5098(%rdi), %r14
leaq 0x5050(%rdi), %r12
leaq 0x618a(%rip), %r15      # 0x132c8
leaq 0x5070(%rdi), %r13
movq 0x50a0(%rbx), %rdx
movl $0x2, %r8d
movq %r14, %rdi
xorl %esi, %esi
leaq 0x655d(%rip), %rcx      # 0x136bb
callq 0x22b0
movq %rbx, %rdi
callq 0xc41a
movq %r12, %rdi
leaq 0x61bd(%rip), %rsi      # 0x13332
callq 0x2080
testl %eax, %eax
je 0xd1ca
movq %r12, %rdi
leaq 0x61b0(%rip), %rsi      # 0x13338
callq 0x2080
testl %eax, %eax
je 0xd1ca
movq %r12, %rdi
leaq 0x6523(%rip), %rsi      # 0x136be
callq 0x2080
testl %eax, %eax
je 0xd1ca
movq %r12, %rdi
leaq 0x5e79(%rip), %rsi      # 0x13027
callq 0x2080
testl %eax, %eax
je 0xd1ca
movq %r12, %rdi
leaq 0x617f(%rip), %rsi      # 0x13340
callq 0x2080
testl %eax, %eax
jne 0xd236
movq %rbx, %rdi
callq 0xd34a
movq %r12, %rdi
movq %r15, %rsi
callq 0x2080
testl %eax, %eax
jne 0xd20d
movq %r13, %rdi
movq %r12, %rsi
callq 0x2100
movslq 0x2028(%rbx), %rsi
shlq $0x5, %rsi
addq %rbx, %rsi
movq %r12, %rdi
callq 0x2100
incl 0x2028(%rbx)
jmp 0xd145
leaq 0x67fb(%rip), %rsi      # 0x13a0f
movq %r12, %rdi
callq 0x2080
testl %eax, %eax
je 0xd236
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xc1be
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop