LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O1/riyadparvez[P]louvain-method/community.cpp
// Function: Community::init_partition(char*)
void
Community::init_partition(char * filename) {
  ifstream finput;
  finput.open(filename,fstream::in);

  // read partition
  while (!finput.eof()) {
    unsigned int node, comm;
    finput >> node >> comm;
    
    if (finput) {
      int old_comm = n2c[node];
      neigh_comm(node);

      remove(node, old_comm, neigh_weight[old_comm]);

      unsigned int i=0;
      for ( i=0 ; i<neigh_last ; i++) {
	unsigned int best_comm     = neigh_pos[i];
	float best_nblinks  = neigh_weight[neigh_pos[i]];
	if (best_comm==comm) {
	  insert(node, best_comm, best_nblinks);
	  break;
	}
      }
      if (i==neigh_last)
	insert(node, comm, 0);
    }
  }
  finput.close();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x218, %rsp            # imm = 0x218
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x10(%rsp), %r15
movq %r15, %rdi
callq 0x2220
movq %r15, %rdi
movq %r14, %rsi
movl $0x8, %edx
callq 0x2120
movq 0x10(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x30(%rsp,%rax)
jne 0x44bc
leaq 0x10(%rsp), %r14
leaq 0x8(%rsp), %r15
leaq 0xc(%rsp), %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x2360
movq %rax, %rdi
movq %r12, %rsi
callq 0x2360
movq 0x10(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x30(%rsp,%rax)
jne 0x44a8
movl 0x8(%rsp), %esi
movq 0xb8(%rbx), %rax
movslq (%rax,%rsi,4), %r13
movq %rbx, %rdi
callq 0x4500
movl 0x8(%rsp), %esi
movq (%rbx), %rax
movsd (%rax,%r13,8), %xmm0
movq %rbx, %rdi
movl %r13d, %edx
callq 0x557e
cmpl $0x0, 0x30(%rbx)
je 0x448e
movq %r15, %r12
movq %r14, %r15
xorl %ebp, %ebp
movq 0x18(%rbx), %rax
movl (%rax,%rbp,4), %r13d
movl 0xc(%rsp), %r14d
cmpl %r14d, %r13d
jne 0x4476
movq (%rbx), %rax
xorps %xmm0, %xmm0
cvtsd2ss (%rax,%r13,8), %xmm0
movl 0x8(%rsp), %esi
cvtss2sd %xmm0, %xmm0
movq %rbx, %rdi
movl %r13d, %edx
callq 0x5730
cmpl %r14d, %r13d
je 0x4481
incq %rbp
movl 0x30(%rbx), %eax
cmpq %rax, %rbp
jb 0x4440
movq %r15, %r14
movq %r12, %r15
leaq 0xc(%rsp), %r12
jmp 0x4490
xorl %ebp, %ebp
cmpl 0x30(%rbx), %ebp
jne 0x44a8
movl 0x8(%rsp), %esi
movl 0xc(%rsp), %edx
xorps %xmm0, %xmm0
movq %rbx, %rdi
callq 0x5730
movq 0x10(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x30(%rsp,%rax)
je 0x43d9
leaq 0x10(%rsp), %rdi
callq 0x2060
leaq 0x10(%rsp), %rdi
callq 0x2070
addq $0x218, %rsp            # imm = 0x218
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x44ea
jmp 0x44ea
jmp 0x44ea
jmp 0x44ea
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x2370
nop
// File: /workspace/github_cpp_makefile_star2_O1/riyadparvez[P]louvain-method/community.cpp
// Function: Community::neigh_comm(unsigned int)
void
Community::neigh_comm(unsigned int node) {
  for (unsigned int i=0 ; i<neigh_last ; i++)
    neigh_weight[neigh_pos[i]]=-1;
  neigh_last=0;

  pair<vector<unsigned int>::iterator, vector<float>::iterator> p = g.neighbors(node);

  unsigned int deg = g.nb_neighbors(node);

  neigh_pos[0]=n2c[node];
  neigh_weight[neigh_pos[0]]=0;
  neigh_last=1;

  for (unsigned int i=0 ; i<deg ; i++) {
    unsigned int neigh        = *(p.first+i);
    unsigned int neigh_comm   = n2c[neigh];
    double neigh_w = (g.weights.size()==0)?1.:*(p.second+i);
    
    if (neigh!=node) {
      if (neigh_weight[neigh_comm]==-1) {
	    neigh_weight[neigh_comm]=0.;
	    neigh_pos[neigh_last++]=neigh_comm;
      }
      neigh_weight[neigh_comm]+=neigh_w;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl 0x30(%rdi), %eax
testq %rax, %rax
je 0x4534
movq (%rdi), %rcx
movq 0x18(%rdi), %rdx
xorl %r8d, %r8d
movabsq $-0x4010000000000000, %r9 # imm = 0xBFF0000000000000
movl (%rdx,%r8,4), %r10d
movq %r9, (%rcx,%r10,8)
incq %r8
cmpq %r8, %rax
jne 0x4524
movl $0x0, 0x30(%rdi)
cmpl %esi, 0x38(%rdi)
jbe 0x4656
testl %esi, %esi
je 0x457d
movq 0x50(%rdi), %rax
leal -0x1(%rsi), %ecx
movq (%rax,%rcx,8), %rcx
leaq (,%rcx,4), %rax
addq 0x80(%rdi), %rax
movq 0x98(%rdi), %rdx
xorl %r8d, %r8d
cmpq %rdx, 0xa0(%rdi)
cmovneq %rcx, %r8
leaq (%rdx,%r8,4), %rcx
jmp 0x458b
movq 0x80(%rdi), %rax
movq 0x98(%rdi), %rcx
movl %esi, %r9d
testl %esi, %esi
je 0x45a4
movq 0x50(%rdi), %rdx
movq (%rdx,%r9,8), %rbx
leal -0x1(%rsi), %r8d
subq (%rdx,%r8,8), %rbx
jmp 0x45aa
movq 0x50(%rdi), %rdx
movl (%rdx), %ebx
movq 0x18(%rdi), %rdx
movq 0xb8(%rdi), %r8
movl (%r8,%r9,4), %r10d
movl %r10d, (%rdx)
movq (%rdi), %r9
movq $0x0, (%r9,%r10,8)
movl $0x1, 0x30(%rdi)
testl %ebx, %ebx
je 0x464d
movq 0x98(%rdi), %r10
movq 0xa0(%rdi), %r11
movl %ebx, %ebx
xorl %r14d, %r14d
movsd 0x3b8b(%rip), %xmm0     # 0x8178
movsd 0x3b8b(%rip), %xmm1     # 0x8180
movaps %xmm0, %xmm2
cmpq %r10, %r11
je 0x4606
xorps %xmm2, %xmm2
cvtss2sd (%rcx,%r14,4), %xmm2
movl (%rax,%r14,4), %r15d
cmpl %esi, %r15d
je 0x4645
movl (%r8,%r15,4), %r15d
movsd (%r9,%r15,8), %xmm3
ucomisd %xmm1, %xmm3
jne 0x4639
jp 0x4639
movq $0x0, (%r9,%r15,8)
movl 0x30(%rdi), %r12d
leal 0x1(%r12), %ebp
movl %ebp, 0x30(%rdi)
movl %r15d, (%rdx,%r12,4)
addsd (%r9,%r15,8), %xmm2
movsd %xmm2, (%r9,%r15,8)
incq %r14
cmpq %r14, %rbx
jne 0x45f5
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3a1e(%rip), %rdi      # 0x807b
leaq 0x3a30(%rip), %rsi      # 0x8094
leaq 0x3a3a(%rip), %rcx      # 0x80a5
movl $0x84, %edx
callq 0x2130
nop
// File: /workspace/github_cpp_makefile_star2_O1/riyadparvez[P]louvain-method/community.cpp
// Function: Community::modularity()
double
Community::modularity() {
  double q  = 0.;
  double m2 = (double)g.total_weight;

  for (int i=0 ; i<size ; i++) {
    if (tot[i]>0)
      q += (double)in[i]/m2 - ((double)tot[i]/m2)*((double)tot[i]/m2);
  }

  return q;
}

// Assembly:
movslq 0xb0(%rdi), %rax
testq %rax, %rax
jle 0x47e0
movsd 0x48(%rdi), %xmm1
movq 0xd0(%rdi), %rcx
movq 0xe8(%rdi), %rdx
xorpd %xmm2, %xmm2
xorl %esi, %esi
xorpd %xmm0, %xmm0
movsd (%rdx,%rsi,8), %xmm3
ucomisd %xmm2, %xmm3
jbe 0x47d7
movsd (%rcx,%rsi,8), %xmm4
divsd %xmm1, %xmm4
divsd %xmm1, %xmm3
mulsd %xmm3, %xmm3
subsd %xmm3, %xmm4
addsd %xmm4, %xmm0
incq %rsi
cmpq %rsi, %rax
jne 0x47b3
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O1/riyadparvez[P]louvain-method/community.cpp
// Function: Community::display_partition()
void
Community::display_partition() {
  vector<int> renumber(size, -1);
  for (int node=0 ; node<size ; node++) {
    renumber[n2c[node]]++;
  }

  int final=0;
  for (int i=0 ; i<size ; i++)
    if (renumber[i]!=-1)
      renumber[i]=final++;

  for (int i=0 ; i<size ; i++)
    cout << i << " " << renumber[n2c[i]] << endl;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
movq %rdi, %rbx
movslq 0xb0(%rdi), %rsi
leaq 0x2c(%rsp), %rdx
movl $0xffffffff, (%rdx)     # imm = 0xFFFFFFFF
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rcx
callq 0x58d6
cmpl $0x0, 0xb0(%rbx)
jle 0x4a62
movq 0xb8(%rbx), %rax
movq 0x10(%rsp), %rcx
xorl %edx, %edx
movslq (%rax,%rdx,4), %rsi
incl (%rcx,%rsi,4)
incq %rdx
movslq 0xb0(%rbx), %rsi
cmpq %rsi, %rdx
jl 0x4a4c
cmpl $0x0, 0xb0(%rbx)
jle 0x4a8e
xorl %eax, %eax
movq 0x10(%rsp), %rcx
xorl %edx, %edx
cmpl $-0x1, (%rcx,%rax,4)
je 0x4a7f
movl %edx, (%rcx,%rax,4)
incl %edx
incq %rax
movslq 0xb0(%rbx), %rsi
cmpq %rsi, %rax
jl 0x4a74
cmpl $0x0, 0xb0(%rbx)
jle 0x4b1e
xorl %r14d, %r14d
movq 0x752b(%rip), %r15      # 0xbfd0
leaq 0x3c17(%rip), %r12      # 0x86c3
movq %r15, %rdi
movl %r14d, %esi
callq 0x2350
movq %rax, %r13
movl $0x1, %edx
movq %rax, %rdi
movq %r12, %rsi
callq 0x2230
movq 0xb8(%rbx), %rax
movslq (%rax,%r14,4), %rax
movq 0x10(%rsp), %rcx
movl (%rcx,%rax,4), %esi
movq %r13, %rdi
callq 0x2350
movq %rax, %r13
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x21d0
movsbl %al, %esi
movq %r13, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2150
incq %r14
movslq 0xb0(%rbx), %rax
cmpq %rax, %r14
jl 0x4aac
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x4b35
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x2200
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x4b5d
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x2200
movq %rbx, %rdi
callq 0x2370
nop
// File: /workspace/github_cpp_makefile_star2_O1/riyadparvez[P]louvain-method/./community.h
// Function: Community::remove(int, int, double)
inline void
Community::remove(int node, int comm, double dnodecomm) {
  assert(node>=0 && node<size);

  tot[comm] -= g.weighted_degree(node);
  in[comm]  -= 2*dnodecomm + g.nb_selfloops(node);
  n2c[node]  = -1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testl %esi, %esi
js 0x56f2
cmpl %esi, 0xb0(%rdi)
jle 0x56f2
cmpl %esi, 0x38(%rdi)
jbe 0x5711
movq 0x98(%rdi), %rcx
movq 0xa0(%rdi), %r8
movl %esi, %eax
cmpq %rcx, %r8
je 0x5605
movq %rcx, %r9
testl %esi, %esi
je 0x55cc
leal -0x1(%rsi), %r9d
movq 0x50(%rdi), %r10
movq (%r10,%r9,8), %r9
leaq (%rcx,%r9,4), %r9
movq 0x50(%rdi), %r10
leal -0x1(%rsi), %r11d
xorpd %xmm1, %xmm1
xorl %ebx, %ebx
testl %esi, %esi
je 0x55e8
movq (%r10,%rax,8), %r14
subq (%r10,%r11,8), %r14
jmp 0x55eb
movl (%r10), %r14d
movl %r14d, %r14d
cmpq %r14, %rbx
jae 0x562a
xorps %xmm2, %xmm2
cvtss2sd (%r9,%rbx,4), %xmm2
addsd %xmm2, %xmm1
incq %rbx
jmp 0x55da
testl %esi, %esi
je 0x561b
movq 0x50(%rdi), %r10
movq (%r10,%rax,8), %r9
leal -0x1(%rsi), %r11d
subq (%r10,%r11,8), %r9
jmp 0x5622
movq 0x50(%rdi), %r9
movq (%r9), %r9
movl %r9d, %r9d
cvtsi2sd %r9, %xmm1
movslq %edx, %rdx
movq 0xe8(%rdi), %r9
movsd (%r9,%rdx,8), %xmm2
subsd %xmm1, %xmm2
movsd %xmm2, (%r9,%rdx,8)
movq 0x80(%rdi), %r9
testl %esi, %esi
je 0x566f
leal -0x1(%rsi), %r10d
xorl %r11d, %r11d
cmpq %rcx, %r8
movq 0x50(%rdi), %rbx
movq (%rbx,%r10,8), %r10
leaq (%r9,%r10,4), %r9
cmovneq %r10, %r11
leaq (%rcx,%r11,4), %r10
jmp 0x5672
movq %rcx, %r10
movq 0x50(%rdi), %r11
leal -0x1(%rsi), %ebx
xorl %r14d, %r14d
testl %esi, %esi
je 0x568a
movq (%r11,%rax,8), %r15
subq (%r11,%rbx,8), %r15
jmp 0x568d
movl (%r11), %r15d
movl %r15d, %r15d
cmpq %r15, %r14
jae 0x56b3
leaq 0x1(%r14), %r15
cmpl %esi, (%r9,%r14,4)
movq %r15, %r14
jne 0x567c
cmpq %rcx, %r8
je 0x56b9
xorps %xmm1, %xmm1
cvtss2sd -0x4(%r10,%r15,4), %xmm1
jmp 0x56c1
xorpd %xmm1, %xmm1
jmp 0x56c1
movsd 0x2ab7(%rip), %xmm1     # 0x8178
addsd %xmm0, %xmm0
addsd %xmm1, %xmm0
movq 0xd0(%rdi), %rcx
movsd (%rcx,%rdx,8), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, (%rcx,%rdx,8)
movq 0xb8(%rdi), %rcx
movl $0xffffffff, (%rcx,%rax,4) # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %r15
retq
leaq 0x2ae6(%rip), %rdi      # 0x81df
leaq 0x2af4(%rip), %rsi      # 0x81f4
leaq 0x2afb(%rip), %rcx      # 0x8202
movl $0x68, %edx
callq 0x2130
leaq 0x2963(%rip), %rdi      # 0x807b
leaq 0x2975(%rip), %rsi      # 0x8094
leaq 0x2a64(%rip), %rcx      # 0x818a
movl $0x74, %edx
callq 0x2130
// File: /workspace/github_cpp_makefile_star2_O1/riyadparvez[P]louvain-method/./community.h
// Function: Community::insert(int, int, double)
inline void
Community::insert(int node, int comm, double dnodecomm) {
  assert(node>=0 && node<size);

  tot[comm] += g.weighted_degree(node);
  in[comm]  += 2*dnodecomm + g.nb_selfloops(node);
  n2c[node]=comm;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testl %esi, %esi
js 0x5898
cmpl %esi, 0xb0(%rdi)
jle 0x5898
cmpl %esi, 0x38(%rdi)
jbe 0x58b7
movq 0x98(%rdi), %rcx
movq 0xa0(%rdi), %r8
movl %esi, %eax
cmpq %rcx, %r8
je 0x57b7
movq %rcx, %r9
testl %esi, %esi
je 0x577e
leal -0x1(%rsi), %r9d
movq 0x50(%rdi), %r10
movq (%r10,%r9,8), %r9
leaq (%rcx,%r9,4), %r9
movq 0x50(%rdi), %r10
leal -0x1(%rsi), %r11d
xorpd %xmm1, %xmm1
xorl %ebx, %ebx
testl %esi, %esi
je 0x579a
movq (%r10,%rax,8), %r14
subq (%r10,%r11,8), %r14
jmp 0x579d
movl (%r10), %r14d
movl %r14d, %r14d
cmpq %r14, %rbx
jae 0x57dc
xorps %xmm2, %xmm2
cvtss2sd (%r9,%rbx,4), %xmm2
addsd %xmm2, %xmm1
incq %rbx
jmp 0x578c
testl %esi, %esi
je 0x57cd
movq 0x50(%rdi), %r10
movq (%r10,%rax,8), %r9
leal -0x1(%rsi), %r11d
subq (%r10,%r11,8), %r9
jmp 0x57d4
movq 0x50(%rdi), %r9
movq (%r9), %r9
movl %r9d, %r9d
cvtsi2sd %r9, %xmm1
movslq %edx, %rdx
movq 0xe8(%rdi), %r9
addsd (%r9,%rdx,8), %xmm1
movsd %xmm1, (%r9,%rdx,8)
movq 0x80(%rdi), %r9
testl %esi, %esi
je 0x581d
leal -0x1(%rsi), %r10d
xorl %r11d, %r11d
cmpq %rcx, %r8
movq 0x50(%rdi), %rbx
movq (%rbx,%r10,8), %r10
leaq (%r9,%r10,4), %r9
cmovneq %r10, %r11
leaq (%rcx,%r11,4), %r10
jmp 0x5820
movq %rcx, %r10
movq 0x50(%rdi), %r11
leal -0x1(%rsi), %ebx
xorl %r14d, %r14d
testl %esi, %esi
je 0x5838
movq (%r11,%rax,8), %r15
subq (%r11,%rbx,8), %r15
jmp 0x583b
movl (%r11), %r15d
movl %r15d, %r15d
cmpq %r15, %r14
jae 0x5861
leaq 0x1(%r14), %r15
cmpl %esi, (%r9,%r14,4)
movq %r15, %r14
jne 0x582a
cmpq %rcx, %r8
je 0x5867
xorps %xmm1, %xmm1
cvtss2sd -0x4(%r10,%r15,4), %xmm1
jmp 0x586f
xorpd %xmm1, %xmm1
jmp 0x586f
movsd 0x2909(%rip), %xmm1     # 0x8178
addsd %xmm0, %xmm0
addsd %xmm1, %xmm0
movq 0xd0(%rdi), %rcx
addsd (%rcx,%rdx,8), %xmm0
movsd %xmm0, (%rcx,%rdx,8)
movq 0xb8(%rdi), %rcx
movl %edx, (%rcx,%rax,4)
popq %rbx
popq %r14
popq %r15
retq
leaq 0x2940(%rip), %rdi      # 0x81df
leaq 0x294e(%rip), %rsi      # 0x81f4
leaq 0x297e(%rip), %rcx      # 0x822b
movl $0x71, %edx
callq 0x2130
leaq 0x27bd(%rip), %rdi      # 0x807b
leaq 0x27cf(%rip), %rsi      # 0x8094
leaq 0x28be(%rip), %rcx      # 0x818a
movl $0x74, %edx
callq 0x2130
// File: /workspace/github_cpp_makefile_star2_O1/riyadparvez[P]louvain-method/main_community.cpp
// Function: usage(char*, char const*)
void
usage(char *prog_name, const char *more) {
  cerr << more;
  cerr << "usage: " << prog_name << " input_file [-w weight_file] [-p part_file] [-q epsilon] [-l display_level] [-v] [-h]" << endl << endl;
  cerr << "input_file: file containing the graph to decompose in communities." << endl;
  cerr << "-w file\tread the graph as a weighted one (weights are set to 1 otherwise)." << endl;
  cerr << "-o write communities into file, one community per line (default turned off)." << endl;
  cerr << "-p file\tstart the computation with a given partition instead of the trivial partition." << endl;
  cerr << "\tfile must contain lines \"node community\"." << endl;
  cerr << "-q eps\ta given pass stops when the modularity is increased by less than epsilon." << endl;
  cerr << "-l k\tdisplays the graph of level k rather than the hierachical structure." << endl;
  cerr << "\tif k=-1 then displays the hierarchical structure rather than the graph at a given level." << endl;
  cerr << "-v\tverbose mode: gives computation time, information about the hierarchy and modularity." << endl;
  cerr << "-h\tshow this usage message." << endl;
  exit(0);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movq 0x53ce(%rip), %rbx      # 0xbff0
movq %rbx, %rdi
callq 0x21e0
leaq 0x16f3(%rip), %rsi      # 0x8324
movq %rbx, %rdi
callq 0x21e0
movq %rax, %rdi
movq %r14, %rsi
callq 0x21e0
leaq 0x16e1(%rip), %rsi      # 0x832c
movq %rax, %rdi
callq 0x21e0
movq %rax, %rdi
callq 0x20f0
movq %rax, %rdi
callq 0x20f0
leaq 0x1718(%rip), %rsi      # 0x8382
movq %rbx, %rdi
callq 0x21e0
movq %rax, %rdi
callq 0x20f0
leaq 0x1744(%rip), %rsi      # 0x83c5
movq %rbx, %rdi
callq 0x21e0
movq %rax, %rdi
callq 0x20f0
leaq 0x1778(%rip), %rsi      # 0x8410
movq %rbx, %rdi
callq 0x21e0
movq %rax, %rdi
callq 0x20f0
leaq 0x17ae(%rip), %rsi      # 0x845d
movq %rbx, %rdi
callq 0x21e0
movq %rax, %rdi
callq 0x20f0
leaq 0x17ee(%rip), %rsi      # 0x84b4
movq %rbx, %rdi
callq 0x21e0
movq %rax, %rdi
callq 0x20f0
leaq 0x1802(%rip), %rsi      # 0x84df
movq %rbx, %rdi
callq 0x21e0
movq %rax, %rdi
callq 0x20f0
leaq 0x183c(%rip), %rsi      # 0x8530
movq %rbx, %rdi
callq 0x21e0
movq %rax, %rdi
callq 0x20f0
leaq 0x186f(%rip), %rsi      # 0x857a
movq %rbx, %rdi
callq 0x21e0
movq %rax, %rdi
callq 0x20f0
leaq 0x18b2(%rip), %rsi      # 0x85d4
movq %rbx, %rdi
callq 0x21e0
movq %rax, %rdi
callq 0x20f0
leaq 0x18f4(%rip), %rsi      # 0x862d
movq %rbx, %rdi
callq 0x21e0
movq %rax, %rdi
callq 0x20f0
xorl %edi, %edi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O1/riyadparvez[P]louvain-method/main_community.cpp
// Function: parse_args(int, char**)
void
parse_args(int argc, char **argv) {
  if (argc<2)
    usage(argv[0], "Bad arguments number\n");

  for (int i = 1; i < argc; i++) {
    if(argv[i][0] == '-') {
      switch(argv[i][1]) {
      case 'w':
	type = WEIGHTED;
        filename_w = argv[i+1];
	i++;
	break;
      case 'o':
        write_community = true;
        filename_comm = argv[i+1];
    i++;
    break;
      case 'p':
        filename_part = argv[i+1];
	i++;
	break;
      case 'q':
	precision = atof(argv[i+1]);
	i++;
	break;
      case 'l':
	display_level = atoi(argv[i+1]);
	i++;
	break;
      case 'k':
	k1 = atoi(argv[i+1]);
	i++;
	break;
      case 'v':
	verbose=true;
	break;
      default:
	usage(argv[0], "Unknown option\n");
      }
    } else {
      if (filename==NULL)
        filename = argv[i];
      else
        usage(argv[0], "More than one filename\n");
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
cmpl $0x2, %edi
jl 0x6e7d
movl %edi, %ebp
movl $0x1, %r12d
movq 0x548d(%rip), %r15      # 0xc200
leaq 0x1576(%rip), %r14      # 0x82f0
movslq %r12d, %rax
movq (%rbx,%rax,8), %rcx
cmpb $0x2d, (%rcx)
jne 0x6db5
movzbl 0x1(%rcx), %ecx
addl $-0x6b, %ecx
cmpl $0xc, %ecx
ja 0x6e6e
movslq (%r14,%rcx,4), %rcx
addq %r14, %rcx
jmpq *%rcx
leal 0x1(%rax), %r12d
movq 0x8(%rbx,%rax,8), %rdi
callq 0x22f0
movl %eax, 0x5439(%rip)      # 0xc1ec
jmp 0x6dc8
testq %r15, %r15
jne 0x6e5f
movq %rcx, 0x543b(%rip)      # 0xc200
movq %rcx, %r15
incl %r12d
cmpl %ebp, %r12d
jl 0x6d7a
jmp 0x6e56
leal 0x1(%rax), %r12d
movq 0x8(%rbx,%rax,8), %rdi
callq 0x2260
movsd %xmm0, 0x53f5(%rip)     # 0xc1e0
jmp 0x6dc8
leal 0x1(%rax), %r12d
movq 0x8(%rbx,%rax,8), %rdi
callq 0x22f0
movl %eax, 0x53e7(%rip)      # 0xc1e8
jmp 0x6dc8
movb $0x1, 0x541a(%rip)      # 0xc224
jmp 0x6dc8
movb $0x1, 0x5412(%rip)      # 0xc225
leal 0x1(%rax), %r12d
movq 0x8(%rbx,%rax,8), %rax
movq %rax, 0x53ed(%rip)      # 0xc210
jmp 0x6dc8
leal 0x1(%rax), %r12d
movq 0x8(%rbx,%rax,8), %rax
movq %rax, 0x53e3(%rip)      # 0xc218
jmp 0x6dc8
movl $0x0, 0x5397(%rip)      # 0xc1d8
leal 0x1(%rax), %r12d
movq 0x8(%rbx,%rax,8), %rax
movq %rax, 0x53b7(%rip)      # 0xc208
jmp 0x6dc8
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq (%rbx), %rdi
leaq 0x1806(%rip), %rsi      # 0x866f
callq 0x6c14
movq (%rbx), %rdi
leaq 0x17e7(%rip), %rsi      # 0x865f
callq 0x6c14
movq (%rbx), %rdi
leaq 0x17c2(%rip), %rsi      # 0x8649
callq 0x6c14
// File: /workspace/github_cpp_makefile_star2_O1/t0mm4rx[P]piscine_cpp/day01/ex03/ZombieHorde.cpp
// Function: ZombieHorde::ZombieHorde(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
ZombieHorde::ZombieHorde(std::string type, int n)
{
	this->n = n;
	this->type = type;
	this->zombies = new Zombie[n];
	for (int i = 0; i < n; i++)
	{
		this->zombies[i].setType(type);
		this->zombies[i].setName(this->randomName());
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %edx, %r13d
movq %rsi, %r14
movq %rdi, %r15
addq $0x10, %rdi
leaq 0x20(%r15), %rax
movq %rax, 0x40(%rsp)
movq %rax, 0x10(%r15)
movq $0x0, 0x18(%r15)
movb $0x0, 0x20(%r15)
movl %edx, 0x8(%r15)
movq %rdi, 0x38(%rsp)
callq 0x1060
movslq %r13d, %rbx
movq %rbx, %rbp
shlq $0x6, %rbp
leaq 0x8(%rbp), %rax
testl %r13d, %r13d
movq $-0x1, %rdi
cmovnsq %rax, %rdi
movq %rdi, 0x30(%rsp)
callq 0x1030
movq %rbx, (%rax)
movq %rax, (%rsp)
addq $0x8, %rax
movq %rax, 0x8(%rsp)
testl %r13d, %r13d
je 0x16d2
negq %rbp
xorl %r12d, %r12d
movq 0x8(%rsp), %rbx
movq %rbx, %rdi
callq 0x135c
addq $-0x40, %r12
addq $0x40, %rbx
cmpq %r12, %rbp
jne 0x16bd
movq 0x8(%rsp), %rax
movq %rax, (%r15)
testl %r13d, %r13d
jle 0x1781
movl %r13d, %ebp
shlq $0x6, %rbp
xorl %r12d, %r12d
leaq 0x48(%rsp), %r13
movq (%r15), %rbx
leaq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq (%r14), %rsi
movq 0x8(%r14), %rdx
addq %rsi, %rdx
leaq 0x10(%rsp), %rdi
callq 0x1514
addq %r12, %rbx
movq %rbx, %rdi
leaq 0x10(%rsp), %rsi
callq 0x1504
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x173f
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x10f0
movq (%r15), %rbx
movq %r13, %rdi
callq 0x1826
addq %r12, %rbx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x150a
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x1774
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x10f0
addq $0x40, %r12
cmpq %r12, %rbp
jne 0x16f2
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x17fe
movq %rax, %r14
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x1801
movq 0x20(%rsp), %rsi
jmp 0x17c2
movq %rax, %r14
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x1801
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x10f0
jmp 0x1801
movq %rax, %r14
testq %r12, %r12
je 0x17ee
negq %r12
movq (%rsp), %rbx
addq $-0x38, %rbx
leaq (%rbx,%r12), %rdi
callq 0x1cac
addq $-0x40, %r12
jne 0x17df
movq (%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x1140
jmp 0x1801
movq %rax, %r14
movq 0x38(%rsp), %rax
movq (%rax), %rdi
movq 0x40(%rsp), %rax
cmpq %rax, %rdi
je 0x181e
movq (%rax), %rsi
incq %rsi
callq 0x10f0
movq %r14, %rdi
callq 0x1120
// File: /workspace/github_cpp_makefile_star2_O1/t0mm4rx[P]piscine_cpp/day01/ex03/Zombie.cpp
// Function: Zombie::announce()
void Zombie::announce(void)
{
	float nb_a;

	nb_a = rand() % 20 + 2;
	std::cout << "<" << this->name << " (" << this->type << ")> ";
	std::cout << "A";
	for (int i = 0; i < 2 + rand() % 20; i++)
		std::cout << "a";
	std::cout << "h" << std::endl;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
callq 0x1050
movq 0x2c00(%rip), %rbx      # 0x3fd8
leaq 0xc33(%rip), %rsi       # 0x2012
movl $0x1, %edx
movq %rbx, %rdi
callq 0x1100
movq 0x20(%r14), %rsi
movq 0x28(%r14), %rdx
movq %rbx, %rdi
callq 0x1100
movq %rax, %r15
leaq 0xc0e(%rip), %rsi       # 0x2014
movl $0x2, %edx
movq %rax, %rdi
callq 0x1100
movq (%r14), %rsi
movq 0x8(%r14), %rdx
movq %r15, %rdi
callq 0x1100
leaq 0xbee(%rip), %rsi       # 0x2017
movl $0x3, %edx
movq %rax, %rdi
callq 0x1100
leaq 0xbde(%rip), %rsi       # 0x201b
movl $0x1, %edx
movq %rbx, %rdi
callq 0x1100
callq 0x1050
cltq
imulq $0x66666667, %rax, %rcx # imm = 0x66666667
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x23, %rcx
addl %edx, %ecx
shll $0x2, %ecx
leal (%rcx,%rcx,4), %ecx
subl %ecx, %eax
cmpl $-0x1, %eax
jl 0x14be
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movq 0x2b5a(%rip), %r14      # 0x3fd8
leaq 0xb98(%rip), %r15       # 0x201d
movl $0x1, %edx
movq %r14, %rdi
movq %r15, %rsi
callq 0x1100
callq 0x1050
cltq
imulq $0x66666667, %rax, %rcx # imm = 0x66666667
movq %rcx, %rdx
shrq $0x3f, %rdx
sarq $0x23, %rcx
addl %edx, %ecx
shll $0x2, %ecx
leal (%rcx,%rcx,4), %ecx
subl %ecx, %eax
incl %ebp
cmpl %eax, %ebp
jle 0x1485
leaq 0xb5a(%rip), %rsi       # 0x201f
movl $0x1, %edx
movq %rbx, %rdi
callq 0x1100
movq (%rbx), %rax
movq -0x18(%rax), %rdi
addq %rbx, %rdi
movl $0xa, %esi
callq 0x10d0
movsbl %al, %esi
movq %rbx, %rdi
callq 0x1040
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1070
nop
// File: /workspace/github_cpp_makefile_star2_O1/t0mm4rx[P]piscine_cpp/day01/ex03/main.cpp
// Function: main
int main()
{
	srand(time(0));
	ZombieHorde *horde_good;
	ZombieHorde *horde_evil;

	horde_good = new ZombieHorde("good", 5);
	horde_evil = new ZombieHorde("evil", 10);
	std::cout << "Good type:" << std::endl;
	horde_good->announce();
	std::cout << "Evil type:" << std::endl;
	horde_evil->announce();
	delete horde_evil;
	delete horde_good;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
xorl %edi, %edi
callq 0x10b0
movl %eax, %edi
callq 0x10c0
movl $0x30, %edi
callq 0x10e0
movq %rax, %rbx
leaq 0x38(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x381(%rip), %rsi       # 0x209b
leaq 0x37e(%rip), %rdx       # 0x209f
leaq 0x28(%rsp), %rdi
callq 0x15a4
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
movl $0x5, %edx
callq 0x1634
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x1d54
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10f0
movl $0x30, %edi
callq 0x10e0
movq %rax, %r14
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x32e(%rip), %rsi       # 0x20a0
leaq 0x32b(%rip), %rdx       # 0x20a4
leaq 0x8(%rsp), %rdi
callq 0x15a4
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
movl $0xa, %edx
callq 0x1634
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x1dac
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10f0
movq 0x2225(%rip), %r15      # 0x3fd8
leaq 0x2eb(%rip), %rsi       # 0x20a5
movl $0xa, %edx
movq %r15, %rdi
callq 0x1100
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x10d0
movsbl %al, %esi
movq %r15, %rdi
callq 0x1040
movq %rax, %rdi
callq 0x1070
movq %rbx, %rdi
callq 0x1b7c
leaq 0x2b3(%rip), %rsi       # 0x20b0
movl $0xa, %edx
movq %r15, %rdi
callq 0x1100
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x10d0
movsbl %al, %esi
movq %r15, %rdi
callq 0x1040
movq %rax, %rdi
callq 0x1070
movq %r14, %rdi
callq 0x1b7c
movq %r14, %rdi
callq 0x1ad4
movl $0x30, %esi
movq %r14, %rdi
callq 0x10f0
movq %rbx, %rdi
callq 0x1ad4
movl $0x30, %esi
movq %rbx, %rdi
callq 0x10f0
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r15
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x1e90
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10f0
jmp 0x1e90
movq %rax, %r15
movq %r14, %rbx
jmp 0x1eb4
movq %rax, %r15
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x1eb4
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10f0
jmp 0x1eb4
movq %rax, %r15
movl $0x30, %esi
movq %rbx, %rdi
callq 0x10f0
movq %r15, %rdi
callq 0x1120
// File: /workspace/github_cpp_makefile_star2_O1/protonpopsicle[P]lang/src/compiler/ByteCoder.cpp
// Function: ByteCoder::addOp(short, int)
void ByteCoder::addOp(short opcode, int operand) {
    Op op = { opcode, operand };
    ops.push_back(op);
    
    if (!activeJumps.empty()) {
        int len = activeJumps.size();
        for (int i = 0; i < len; i++) {
            activeJumps[i].shift++;
        }
    }
    
    if (!activeLoops.empty()) {
        int len = activeLoops.size();
        for (int i = 0; i < len; i++) {
            activeLoops[i]++;
        }
    }
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movw %si, 0x8(%rsp)
movl %edx, 0xc(%rsp)
movq 0x40(%rdi), %rsi
cmpq 0x48(%rdi), %rsi
je 0x24dc
movq 0x8(%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x40(%rbx)
jmp 0x24ea
leaq 0x38(%rbx), %rdi
leaq 0x8(%rsp), %rdx
callq 0x2fc4
movq 0x50(%rbx), %rax
movq 0x58(%rbx), %rcx
cmpq %rcx, %rax
je 0x2516
subq %rax, %rcx
shrq $0x3, %rcx
testl %ecx, %ecx
jle 0x2516
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
xorl %edx, %edx
incl 0x4(%rax,%rdx,8)
incq %rdx
cmpq %rdx, %rcx
jne 0x250a
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
cmpq %rcx, %rax
je 0x2541
subq %rax, %rcx
shrq $0x2, %rcx
testl %ecx, %ecx
jle 0x2541
andl $0x7fffffff, %ecx       # imm = 0x7FFFFFFF
xorl %edx, %edx
incl (%rax,%rdx,4)
incq %rdx
cmpq %rdx, %rcx
jne 0x2536
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/protonpopsicle[P]lang/src/compiler/ByteCoder.cpp
// Function: ByteCoder::getVar(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
char ByteCoder::getVar(std::string id) {
    switch (zoneMgr->getVarType(id)) {
        case BOOL:
            addOp(OP_GET_BOOL, zoneMgr->getVarIndex(id));
            return BOOL;
        case INT:
            addOp(OP_GET_INT, zoneMgr->getVarIndex(id));
            return INT;
        case STRING:
            addOp(OP_GET_STRING, zoneMgr->getVarIndex(id));
            return STRING;
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rsi, %r15
movq %rdi, %r14
movq 0x68(%rdi), %rbx
leaq 0x10(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%rsi), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
movq %rsp, %r12
movq %r12, %rdi
callq 0x3344
movq %rbx, %rdi
movq %r12, %rsi
callq 0x527e
movl %eax, %ebx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x25e9
movq 0x10(%rsp), %rsi
incq %rsi
callq 0x2160
movq 0x68(%r14), %r12
testb %bl, %bl
je 0x2641
movzbl %bl, %eax
cmpl $0x1, %eax
jne 0x2682
leaq 0x50(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq 0x40(%rsp), %r15
movq %r15, %rdi
callq 0x3344
movq %r12, %rdi
movq %r15, %rsi
callq 0x53f0
movq %r14, %rdi
movl $0x2, %esi
movl %eax, %edx
callq 0x24b2
movq 0x40(%rsp), %rdi
jmp 0x26c1
leaq 0x70(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq 0x60(%rsp), %r15
movq %r15, %rdi
callq 0x3344
movq %r12, %rdi
movq %r15, %rsi
callq 0x53f0
movq %r14, %rdi
movl $0x1, %esi
movl %eax, %edx
callq 0x24b2
movq 0x60(%rsp), %rdi
jmp 0x26c1
leaq 0x30(%rsp), %r13
movq %r13, -0x10(%r13)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq 0x20(%rsp), %r15
movq %r15, %rdi
callq 0x3344
movq %r12, %rdi
movq %r15, %rsi
callq 0x53f0
movq %r14, %rdi
movl $0x3, %esi
movl %eax, %edx
callq 0x24b2
movq 0x20(%rsp), %rdi
cmpq %r13, %rdi
je 0x26d2
movq (%r13), %rsi
incq %rsi
callq 0x2160
movl %ebx, %eax
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq %rax, %rbx
movq 0x20(%rsp), %rdi
jmp 0x270a
movq %rax, %rbx
movq 0x60(%rsp), %rdi
jmp 0x270a
movq %rax, %rbx
movq 0x40(%rsp), %rdi
jmp 0x270a
movq %rax, %rbx
movq (%rsp), %rdi
cmpq %r13, %rdi
je 0x271b
movq (%r13), %rsi
incq %rsi
callq 0x2160
movq %rbx, %rdi
callq 0x2250
nop
// File: /workspace/github_cpp_makefile_star2_O1/protonpopsicle[P]lang/src/compiler/ByteCoder.cpp
// Function: ByteCoder::evalUnary(char)
char ByteCoder::evalUnary(char rhs) { 
    if (rhs == INT) {
        addOp(OP_PUSH, -1);
        addOp(OP_MULTIPLY, 0);
        return INT;
    }
    throw Error("type mismatch in unary expression");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
cmpb $0x1, %sil
jne 0x29cf
movq %rdi, %rbx
xorl %esi, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x24b2
movq %rbx, %rdi
movl $0x9, %esi
xorl %edx, %edx
callq 0x24b2
movb $0x1, %al
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x20c0
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x4659(%rip), %rsi      # 0x7045
leaq 0x4673(%rip), %rdx      # 0x7066
leaq 0x8(%rsp), %rdi
callq 0x33d4
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x36dc
xorl %ebp, %ebp
leaq 0x839a(%rip), %rsi      # 0xadb0
leaq 0x581(%rip), %rdx       # 0x2f9e
movq %rbx, %rdi
callq 0x2240
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x2a47
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2160
jmp 0x2a47
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x2a54
movq %rbx, %rdi
callq 0x2100
movq %r14, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O1/protonpopsicle[P]lang/src/compiler/ByteCoder.cpp
// Function: ByteCoder::evalArith(char, char, char)
char ByteCoder::evalArith(char oper, char lhs, char rhs) {
    if (lhs == INT && rhs == INT) {
        switch (oper) {
            case '+':
                addOp(OP_ADD, 0);
                break;
            case '-':
                addOp(OP_SUBTRACT, 0);
                break;
            case '*':
                addOp(OP_MULTIPLY, 0);
                break;
            case '/':
                addOp(OP_DIVIDE, 0);
                break;
        }
        return INT;
    }
    if (oper == '+') {          
        if (lhs == STRING && rhs == STRING) {
            addOp(OP_CAT_STRING, 0);
        }
        else if (lhs == STRING && rhs == INT) {
            addOp(OP_CAT_STRING_INT, 0);
        }
        else if (lhs == INT && rhs == STRING) {
            addOp(OP_CAT_INT_STRING, 0);
        }
        return STRING;
    }
    throw Error("type mismatch in arithmetic expression");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %edx, %eax
xorb $0x1, %al
movl %ecx, %r8d
xorb $0x1, %r8b
movl %eax, %r9d
orb %r8b, %r9b
jne 0x2aa0
addb $-0x2a, %sil
movb $0x1, %bl
cmpb $0x6, %sil
jae 0x2ad5
movzbl %sil, %eax
movl $0x2b, %ecx
btl %eax, %ecx
jae 0x2ad5
leaq 0x457a(%rip), %rcx      # 0x7014
movzwl (%rcx,%rax,2), %esi
jmp 0x2acb
cmpb $0x2b, %sil
jne 0x2ae2
xorb $0x2, %dl
xorb $0x2, %cl
movb $0x2, %bl
movw $0xb, %si
movl %edx, %r9d
orb %cl, %r9b
je 0x2acb
movw $0xc, %si
orb %r8b, %dl
je 0x2acb
movw $0xd, %si
orb %cl, %al
jne 0x2ad5
movswl %si, %esi
xorl %edx, %edx
callq 0x24b2
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x20c0
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x4568(%rip), %rsi      # 0x7067
leaq 0x4587(%rip), %rdx      # 0x708d
leaq 0x8(%rsp), %rdi
callq 0x33d4
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x36dc
xorl %ebp, %ebp
leaq 0x8287(%rip), %rsi      # 0xadb0
leaq 0x46e(%rip), %rdx       # 0x2f9e
movq %rbx, %rdi
callq 0x2240
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x2b5a
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2160
jmp 0x2b5a
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x2b67
movq %rbx, %rdi
callq 0x2100
movq %r14, %rdi
callq 0x2250
nop
// File: /workspace/github_cpp_makefile_star2_O1/protonpopsicle[P]lang/src/compiler/ByteCoder.cpp
// Function: ByteCoder::evalBool(short, char, char)
char ByteCoder::evalBool(short oper, char lhs, char rhs) {
    // relational expression
    if (lhs == INT && rhs == INT) {
        switch (oper) {
            case '<':
                addOp(OP_L, 0);
                break;
            case '>':
                addOp(OP_G, 0);
                break;
            case LE:
                addOp(OP_LE, 0);
                break;
            case GE:
                addOp(OP_GE, 0);
                break;
            case EQ:
                addOp(OP_EQ, 0);
                break;
            case NE:
                addOp(OP_NE, 0);
        }
        return BOOL;
    }
    // logical expression
    if (lhs == BOOL && rhs == BOOL) {
        switch (oper) {
            case AND:
                addOp(OP_AND, 0);
                break;
            case OR:
                addOp(OP_OR, 0);
                break;
        }
        return BOOL;
    }
    throw Error("type mismatch in boolean expression");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %edx, %eax
xorb $0x1, %al
movl %ecx, %r8d
xorb $0x1, %r8b
orb %al, %r8b
jne 0x2bae
movswl %si, %eax
leal -0x12c(%rax), %ecx
cmpl $0x3, %ecx
ja 0x2bc9
leaq 0x4465(%rip), %rax      # 0x7004
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movw $0x16, %ax
jmp 0x2bf5
orb %dl, %cl
jne 0x2c0c
movswl %si, %eax
cmpl $0x130, %eax            # imm = 0x130
je 0x2bd9
cmpl $0x131, %eax            # imm = 0x131
jne 0x2bff
movw $0x1b, %ax
jmp 0x2bf5
cmpl $0x3c, %eax
je 0x2bdf
cmpl $0x3e, %eax
jne 0x2bff
movw $0x15, %ax
jmp 0x2bf5
movw $0x1a, %ax
jmp 0x2bf5
movw $0x14, %ax
jmp 0x2bf5
movw $0x18, %ax
jmp 0x2bf5
movw $0x19, %ax
jmp 0x2bf5
movw $0x17, %ax
movzwl %ax, %esi
xorl %edx, %edx
callq 0x24b2
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x20c0
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x4465(%rip), %rsi      # 0x708e
leaq 0x4481(%rip), %rdx      # 0x70b1
leaq 0x8(%rsp), %rdi
callq 0x33d4
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x36dc
xorl %ebp, %ebp
leaq 0x815d(%rip), %rsi      # 0xadb0
leaq 0x344(%rip), %rdx       # 0x2f9e
movq %rbx, %rdi
callq 0x2240
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x2c84
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2160
jmp 0x2c84
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x2c91
movq %rbx, %rdi
callq 0x2100
movq %r14, %rdi
callq 0x2250
nop
// File: /workspace/github_cpp_makefile_star2_O1/protonpopsicle[P]lang/src/compiler/ByteCoder.cpp
// Function: ByteCoder::print(char)
void ByteCoder::print(char rhs) {
    switch (rhs) {
        case INT:
            addOp(OP_PRINT_INT, 0);
            break;
        case STRING:
            addOp(OP_PRINT_STRING, 0);
            break;
        default:
            throw Error("type mismatch in print statement");
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movw $0xe, %ax
cmpl $0x1, %esi
je 0x2cb6
cmpl $0x2, %esi
jne 0x2cca
movw $0xf, %ax
movzwl %ax, %esi
xorl %edx, %edx
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x24b2
movl $0x20, %edi
callq 0x20c0
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x43cb(%rip), %rsi      # 0x70b2
leaq 0x43e4(%rip), %rdx      # 0x70d2
leaq 0x8(%rsp), %rdi
callq 0x33d4
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x36dc
xorl %ebp, %ebp
leaq 0x809f(%rip), %rsi      # 0xadb0
leaq 0x286(%rip), %rdx       # 0x2f9e
movq %rbx, %rdi
callq 0x2240
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x2d42
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2160
jmp 0x2d42
movq %rax, %r14
movb $0x1, %bpl
testb %bpl, %bpl
je 0x2d4f
movq %rbx, %rdi
callq 0x2100
movq %r14, %rdi
callq 0x2250
nop
// File: /workspace/github_cpp_makefile_star2_O1/protonpopsicle[P]lang/src/compiler/ByteCoder.cpp
// Function: ByteCoder::jump()
void ByteCoder::jump() {
    jumpCounter++;
    addOp(OP_JUMP_IF_FALSE, jumpCounter);
    
    Jump jump = { jumpCounter, 0 };
    activeJumps.push_back(jump);
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl (%rdi), %edx
incl %edx
movl %edx, (%rdi)
movl $0x11, %esi
callq 0x24b2
movl (%rbx), %eax
movl %eax, 0x8(%rsp)
movl $0x0, 0xc(%rsp)
movq 0x58(%rbx), %rsi
cmpq 0x60(%rbx), %rsi
je 0x2de7
movq 0x8(%rsp), %rax
movq %rax, (%rsi)
addq $0x8, 0x58(%rbx)
jmp 0x2df8
addq $0x50, %rbx
leaq 0x8(%rsp), %rdx
movq %rbx, %rdi
callq 0x35a0
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O1/protonpopsicle[P]lang/src/compiler/ByteCoder.cpp
// Function: ByteCoder::write(_IO_FILE*)
void ByteCoder::write(FILE *fp) {
    fprintf(fp, "%i ", zoneMgr->boolCount);    // # of bool vars
    fprintf(fp, "%i ", zoneMgr->intCount);     // # of int vars
    fprintf(fp, "%i ", zoneMgr->stringCount);  // # of string vars
    fprintf(fp, "%i ", stringLiterals.size()); // # of string literals
    fprintf(fp, "%i:", ops.size());            // # of operations
    
    int len = stringLiterals.size();
    for (int i = 0; i < len; i++) {
        fprintf(fp, "%s:", stringLiterals[i].c_str());
    }
    
    len = ops.size();
    for (int i = 0; i < len; i++) {
        fprintf(fp, "%i %i ", ops[i].opcode, ops[i].operand);
    }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x68(%rdi), %rax
movl 0x50(%rax), %edx
leaq 0x4279(%rip), %r15      # 0x70de
movq %rsi, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x21e0
movq 0x68(%r14), %rax
movl 0x54(%rax), %edx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x21e0
movq 0x68(%r14), %rax
movl 0x58(%rax), %edx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x21e0
movq 0x28(%r14), %rdx
subq 0x20(%r14), %rdx
sarq $0x5, %rdx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x21e0
movq 0x40(%r14), %rdx
subq 0x38(%r14), %rdx
sarq $0x3, %rdx
leaq 0x420d(%rip), %rsi      # 0x70d3
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21e0
movq 0x28(%r14), %r12
subq 0x20(%r14), %r12
shrq $0x5, %r12
testl %r12d, %r12d
jle 0x2f10
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
leaq 0x41e8(%rip), %r15      # 0x70d7
xorl %r13d, %r13d
movq 0x20(%r14), %rax
movq (%rax,%r13), %rdx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x21e0
addq $0x20, %r13
decq %r12
jne 0x2ef2
movq 0x40(%r14), %r12
subq 0x38(%r14), %r12
shrq $0x3, %r12
testl %r12d, %r12d
jle 0x2f55
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
leaq 0x41ac(%rip), %r15      # 0x70db
xorl %r13d, %r13d
movq 0x38(%r14), %rax
movswl (%rax,%r13,8), %edx
movl 0x4(%rax,%r13,8), %ecx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x21e0
incq %r13
cmpq %r13, %r12
jne 0x2f32
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O1/protonpopsicle[P]lang/src/compiler/Lexer.cpp
// Function: Lexer::Lexer(_IO_FILE*)
Lexer::Lexer(FILE *f) {
    fp = f;
    peek = ' '; 
    line = 1;
    
    keywords.insert(std::make_pair("int", BASIC));
    keywords.insert(std::make_pair("string", BASIC));
    keywords.insert(std::make_pair("bool", BASIC));
    keywords.insert(std::make_pair("true", TRUE));
    keywords.insert(std::make_pair("false", FALSE));
    keywords.insert(std::make_pair("print", PRINT));
    keywords.insert(std::make_pair("if", IF));
    keywords.insert(std::make_pair("while", WHILE));
    keywords.insert(std::make_pair("do", DO));
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
movl $0x0, 0x8(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
movq %rsi, 0x30(%rdi)
movb $0x20, 0x38(%rdi)
movl $0x1, 0x3c(%rdi)
leaq 0x3662(%rip), %rax      # 0x722f
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movl $0x103, 0x8(%rsi)       # imm = 0x103
callq 0x4260
leaq 0x362e(%rip), %rax      # 0x7216
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movl $0x103, 0x8(%rsi)       # imm = 0x103
movq %rbx, %rdi
callq 0x4260
leaq 0x3617(%rip), %rax      # 0x721d
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movl $0x103, 0x8(%rsi)       # imm = 0x103
movq %rbx, %rdi
callq 0x4260
leaq 0x35fe(%rip), %rax      # 0x7222
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movl $0x104, 0x8(%rsi)       # imm = 0x104
movq %rbx, %rdi
callq 0x4260
leaq 0x35e5(%rip), %rax      # 0x7227
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movl $0x105, 0x8(%rsi)       # imm = 0x105
movq %rbx, %rdi
callq 0x4260
leaq 0x35cd(%rip), %rax      # 0x722d
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movl $0x106, 0x8(%rsi)       # imm = 0x106
movq %rbx, %rdi
callq 0x4260
leaq 0x35b5(%rip), %rax      # 0x7233
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movl $0x107, 0x8(%rsi)       # imm = 0x107
movq %rbx, %rdi
callq 0x4260
leaq 0x359a(%rip), %rax      # 0x7236
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movl $0x108, 0x8(%rsi)       # imm = 0x108
movq %rbx, %rdi
callq 0x4260
leaq 0x3582(%rip), %rax      # 0x723c
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movl $0x109, 0x8(%rsi)       # imm = 0x109
movq %rbx, %rdi
callq 0x4260
addq $0x18, %rsp
popq %rbx
popq %r14
retq
jmp 0x3ce9
jmp 0x3ce9
jmp 0x3ce9
jmp 0x3ce9
jmp 0x3ce9
jmp 0x3ce9
jmp 0x3ce9
jmp 0x3ce9
movq %rax, %r14
movq %rbx, %rdi
callq 0x41e8
movq %r14, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O1/protonpopsicle[P]lang/src/compiler/Parser.cpp
// Function: Parser::Parser(Lexer*, ZoneMgr*, ByteCoder*)
Parser::Parser(Lexer *l, ZoneMgr *z, ByteCoder *b) 
{
    lexer = l;
    zoneMgr = z;
    byteCoder = b;
    
    move();
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r14
movq %rdx, %r15
movq %rsi, %r12
movq %rdi, %rbx
addq $0x18, %rdi
callq 0x4f0c
movq %r12, (%rbx)
movq %r15, 0x8(%rbx)
movq %r14, 0x10(%rbx)
movq %rbx, %rdi
callq 0x4574
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq 0x20(%rbx), %rdi
addq $0x30, %rbx
cmpq %rbx, %rdi
je 0x456b
movq (%rbx), %rsi
incq %rsi
callq 0x2160
movq %r14, %rdi
callq 0x2250
nop
// File: /workspace/github_cpp_makefile_star2_O1/protonpopsicle[P]lang/src/compiler/Parser.cpp
// Function: Parser::match(short)
void Parser::match(short tag) {
    if (look.tag == tag) {
        move();
    }
    else {
        throw Error(tag, look.tag);
    }
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %r14
cmpw %bp, 0x18(%rdi)
jne 0x45e5
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x4574
movl $0x20, %edi
callq 0x20c0
movq %rax, %rbx
movswl 0x18(%r14), %edx
movswl %bp, %esi
movq %rax, %rdi
callq 0x3720
leaq 0x67a7(%rip), %rsi      # 0xadb0
leaq -0x1672(%rip), %rdx     # 0x2f9e
movq %rbx, %rdi
callq 0x2240
movq %rax, %r14
movq %rbx, %rdi
callq 0x2100
movq %r14, %rdi
callq 0x2250
nop
// File: /workspace/github_cpp_makefile_star2_O1/protonpopsicle[P]lang/src/compiler/Parser.cpp
// Function: Parser::block()
void Parser::block() {
    match('{');
    zoneMgr->saveZone();
    zoneMgr->createZone();
    stmts();
    match('}');
    zoneMgr->loadZone();
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x7b, %esi
callq 0x45ca
movq 0x8(%rbx), %rdi
callq 0x503a
movq 0x8(%rbx), %rdi
callq 0x5024
movq %rbx, %rdi
callq 0x4672
movq %rbx, %rdi
movl $0x7d, %esi
callq 0x45ca
movq 0x8(%rbx), %rdi
popq %rbx
jmp 0x5040
nop
// File: /workspace/github_cpp_makefile_star2_O1/protonpopsicle[P]lang/src/compiler/Parser.cpp
// Function: Parser::decl()
void Parser::decl() {
    // decl -> basic id
    std::string type = look.lexeme;
    move();
    std::string id = look.lexeme;
    match(ID);
    zoneMgr->addVar(id, type);
    // restDecl -> = bool
    if (look.tag == '=') {
        match('=');
        char rhs = boolean();
        byteCoder->assignVar(id, rhs);
    }
    // restDecl -> e
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %rdi, %rbx
leaq 0x38(%rsp), %r15
movq %r15, -0x10(%r15)
movq 0x20(%rdi), %rsi
movq 0x28(%rdi), %rdx
addq %rsi, %rdx
leaq 0x28(%rsp), %rdi
callq 0x3344
movq %rbx, %rdi
callq 0x4574
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq 0x20(%rbx), %rsi
movq 0x28(%rbx), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x3344
movq %rbx, %rdi
movl $0x102, %esi            # imm = 0x102
callq 0x45ca
movq 0x8(%rbx), %r14
leaq 0x98(%rsp), %r13
movq %r13, -0x10(%r13)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
leaq 0x88(%rsp), %rdi
callq 0x3344
leaq 0x78(%rsp), %rbp
movq %rbp, -0x10(%rbp)
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
addq %rsi, %rdx
leaq 0x68(%rsp), %rdi
callq 0x3344
leaq 0x88(%rsp), %rsi
leaq 0x68(%rsp), %rdx
movq %r14, %rdi
callq 0x5046
movq 0x68(%rsp), %rdi
cmpq %rbp, %rdi
je 0x497e
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x2160
movq 0x88(%rsp), %rdi
cmpq %r13, %rdi
je 0x499b
movq 0x98(%rsp), %rsi
incq %rsi
callq 0x2160
cmpw $0x3d, 0x18(%rbx)
jne 0x4a05
movq %rbx, %rdi
movl $0x3d, %esi
callq 0x45ca
movq %rbx, %rdi
callq 0x4ada
movl %eax, %ebp
movq 0x10(%rbx), %rbx
leaq 0x58(%rsp), %r14
movq %r14, -0x10(%r14)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
leaq 0x48(%rsp), %rdi
callq 0x3344
movsbl %bpl, %edx
leaq 0x48(%rsp), %rsi
movq %rbx, %rdi
callq 0x2724
movq 0x48(%rsp), %rdi
cmpq %r14, %rdi
je 0x4a05
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x2160
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x4a1c
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2160
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x4a33
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2160
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %rbx
movq 0x48(%rsp), %rdi
cmpq %r14, %rdi
je 0x4aa3
movq 0x58(%rsp), %rsi
jmp 0x4a8f
jmp 0x4aa0
movq %rax, %rbx
movq 0x68(%rsp), %rdi
cmpq %rbp, %rdi
je 0x4a7a
movq 0x78(%rsp), %rsi
incq %rsi
callq 0x2160
jmp 0x4a7a
movq %rax, %rbx
movq 0x88(%rsp), %rdi
cmpq %r13, %rdi
je 0x4aa3
movq 0x98(%rsp), %rsi
incq %rsi
callq 0x2160
jmp 0x4aa3
jmp 0x4a9b
movq %rax, %rbx
jmp 0x4aba
movq %rax, %rbx
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x4aba
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2160
movq 0x28(%rsp), %rdi
cmpq %r15, %rdi
je 0x4ad1
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x2160
movq %rbx, %rdi
callq 0x2250
nop
// File: /workspace/github_cpp_makefile_star2_O1/protonpopsicle[P]lang/src/compiler/Parser.cpp
// Function: Parser::boolean()
char Parser::boolean() {
    char lhs, rhs;
    lhs = join(); // bool -> join restBool
    
    // restBool -> || join restBool
    while (look.tag == OR) {
        move();
        rhs = join();
        lhs = byteCoder->evalBool(OR, lhs, rhs);
    }
    // restBool -> e
    return lhs;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x4b20
movl %eax, %ebp
cmpw $0x131, 0x18(%rbx)      # imm = 0x131
jne 0x4b16
movq %rbx, %rdi
callq 0x4574
movq %rbx, %rdi
callq 0x4b20
movq 0x10(%rbx), %rdi
movsbl %bpl, %edx
movsbl %al, %ecx
movl $0x131, %esi            # imm = 0x131
callq 0x2b70
jmp 0x4ae5
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nop