LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: riyadparvez[P]louvain-method/./graph_binary.h
// Function: Graph::weighted_degree(unsigned int)
inline double
Graph::weighted_degree(unsigned int node) {
  assert(node>=0 && node<nb_nodes);

  if (weights.size()==0)
    return (double)nb_neighbors(node);
  else {
    pair<vector<unsigned int>::iterator, vector<float>::iterator > p = neighbors(node);
    double res = 0;
    for (unsigned int i=0 ; i<nb_neighbors(node) ; i++) {
      res += (double)*(p.second+i);
    }
    return res;
  }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x14(%rbp)
movb %al, -0x41(%rbp)
jb 0x36d1
movq -0x50(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl (%rcx), %eax
setb %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0x36da
jmp 0x36dc
jmp 0x36fb
leaq 0x1197c(%rip), %rdi     # 0x1505f
leaq 0x1198e(%rip), %rsi     # 0x15078
movl $0x74, %edx
leaq 0x11993(%rip), %rcx     # 0x15089
callq 0x2110
movq -0x50(%rbp), %rdi
addq $0x60, %rdi
callq 0x3da0
cmpq $0x0, %rax
jne 0x372b
movq -0x50(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x3c80
movl %eax, %eax
cvtsi2sd %rax, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0x37af
movq -0x50(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x3ad0
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x30(%rbp)
movl $0x0, -0x34(%rbp)
movq -0x50(%rbp), %rdi
movl -0x34(%rbp), %eax
movl %eax, -0x54(%rbp)
movl -0x14(%rbp), %esi
callq 0x3c80
movl %eax, %ecx
movl -0x54(%rbp), %eax
cmpl %ecx, %eax
jae 0x37a5
leaq -0x28(%rbp), %rdi
addq $0x8, %rdi
movl -0x34(%rbp), %eax
movl %eax, %esi
callq 0x3dc0
movq %rax, -0x40(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3e00
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
addsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x374e
movsd -0x30(%rbp), %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: riyadparvez[P]louvain-method/./graph_binary.h
// Function: Graph::neighbors(unsigned int)
inline pair<vector<unsigned int>::iterator, vector<float>::iterator >
Graph::neighbors(unsigned int node) {
  assert(node>=0 && node<nb_nodes);

  if (node==0)
    return make_pair(links.begin(), weights.begin());
  else if (weights.size()!=0)
    return make_pair(links.begin()+degrees[node-1], weights.begin()+degrees[node-1]);
  else
    return make_pair(links.begin()+degrees[node-1], weights.begin());
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x18(%rbp)
movl %esi, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0x78(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x1c(%rbp)
movb %al, -0x69(%rbp)
jb 0x3b04
movq -0x78(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl (%rcx), %eax
setb %al
movb %al, -0x69(%rbp)
movb -0x69(%rbp), %al
testb $0x1, %al
jne 0x3b0d
jmp 0x3b0f
jmp 0x3b2e
leaq 0x11549(%rip), %rdi     # 0x1505f
leaq 0x1155b(%rip), %rsi     # 0x15078
movl $0x84, %edx
leaq 0x1158c(%rip), %rcx     # 0x150b5
callq 0x2110
cmpl $0x0, -0x1c(%rbp)
jne 0x3b70
movq -0x78(%rbp), %rdi
addq $0x48, %rdi
callq 0x41c0
movq -0x78(%rbp), %rdi
movq %rax, -0x28(%rbp)
addq $0x60, %rdi
callq 0x41f0
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x4190
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
jmp 0x3c6c
movq -0x78(%rbp), %rdi
addq $0x60, %rdi
callq 0x3da0
cmpq $0x0, %rax
je 0x3c0e
movq -0x78(%rbp), %rdi
addq $0x48, %rdi
callq 0x41c0
movq -0x78(%rbp), %rdi
movq %rax, -0x40(%rbp)
addq $0x18, %rdi
movl -0x1c(%rbp), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x3400
movq (%rax), %rsi
leaq -0x40(%rbp), %rdi
callq 0x3d40
movq -0x78(%rbp), %rdi
movq %rax, -0x38(%rbp)
addq $0x60, %rdi
callq 0x41f0
movq -0x78(%rbp), %rdi
movq %rax, -0x50(%rbp)
addq $0x18, %rdi
movl -0x1c(%rbp), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x3400
movq (%rax), %rsi
leaq -0x50(%rbp), %rdi
callq 0x3dc0
movq %rax, -0x48(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x4190
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
jmp 0x3c6c
movq -0x78(%rbp), %rdi
addq $0x48, %rdi
callq 0x41c0
movq -0x78(%rbp), %rdi
movq %rax, -0x60(%rbp)
addq $0x18, %rdi
movl -0x1c(%rbp), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x3400
movq (%rax), %rsi
leaq -0x60(%rbp), %rdi
callq 0x3d40
movq -0x78(%rbp), %rdi
movq %rax, -0x58(%rbp)
addq $0x60, %rdi
callq 0x41f0
movq %rax, -0x68(%rbp)
leaq -0x58(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x4190
movq %rax, -0x10(%rbp)
movq %rdx, -0x8(%rbp)
movq -0x10(%rbp), %rax
movq -0x8(%rbp), %rdx
addq $0x80, %rsp
popq %rbp
retq
nopl (%rax)
// File: riyadparvez[P]louvain-method/./graph_binary.h
// Function: Graph::nb_neighbors(unsigned int)
inline unsigned int
Graph::nb_neighbors(unsigned int node) {
  assert(node>=0 && node<nb_nodes);

  if (node==0)
    return degrees[0];
  else
    return degrees[node]-degrees[node-1];
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x20(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x14(%rbp)
movb %al, -0x15(%rbp)
jb 0x3cb1
movq -0x20(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl (%rcx), %eax
setb %al
movb %al, -0x15(%rbp)
movb -0x15(%rbp), %al
testb $0x1, %al
jne 0x3cba
jmp 0x3cbc
jmp 0x3cdb
leaq 0x1139c(%rip), %rdi     # 0x1505f
leaq 0x113ae(%rip), %rsi     # 0x15078
movl $0x5a, %edx
leaq 0x1143c(%rip), %rcx     # 0x15112
callq 0x2110
cmpl $0x0, -0x14(%rbp)
jne 0x3cfa
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
xorl %eax, %eax
movl %eax, %esi
callq 0x3400
movq (%rax), %rax
movl %eax, -0x4(%rbp)
jmp 0x3d37
movq -0x20(%rbp), %rdi
addq $0x18, %rdi
movl -0x14(%rbp), %eax
movl %eax, %esi
callq 0x3400
movq -0x20(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x28(%rbp)
addq $0x18, %rdi
movl -0x14(%rbp), %eax
subl $0x1, %eax
movl %eax, %eax
movl %eax, %esi
callq 0x3400
movq %rax, %rcx
movq -0x28(%rbp), %rax
subq (%rcx), %rax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
// File: 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:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
xorps %xmm0, %xmm0
movsd %xmm0, -0x10(%rbp)
movsd 0x48(%rax), %xmm0
movsd %xmm0, -0x18(%rbp)
movl $0x0, -0x1c(%rbp)
movq -0x28(%rbp), %rcx
movl -0x1c(%rbp), %eax
cmpl 0xb0(%rcx), %eax
jge 0x8a89
movq -0x28(%rbp), %rdi
addq $0xe8, %rdi
movslq -0x1c(%rbp), %rsi
callq 0xa150
movsd (%rax), %xmm0
xorps %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jbe 0x8a79
movq -0x28(%rbp), %rdi
addq $0xd0, %rdi
movslq -0x1c(%rbp), %rsi
callq 0xa150
movq -0x28(%rbp), %rdi
movsd (%rax), %xmm0
divsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
addq $0xe8, %rdi
movslq -0x1c(%rbp), %rsi
callq 0xa150
movq -0x28(%rbp), %rdi
movsd (%rax), %xmm0
divsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
addq $0xe8, %rdi
movslq -0x1c(%rbp), %rsi
callq 0xa150
movsd -0x38(%rbp), %xmm0
movsd -0x30(%rbp), %xmm1
movsd (%rax), %xmm2
divsd -0x18(%rbp), %xmm2
movq %xmm0, %rax
movabsq $-0x8000000000000000, %rcx # imm = 0x8000000000000000
xorq %rcx, %rax
movq %rax, %xmm0
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
addsd -0x10(%rbp), %xmm0
movsd %xmm0, -0x10(%rbp)
jmp 0x8a7b
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x89ad
movsd -0x10(%rbp), %xmm0
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x60(%rbp)
movslq 0xb0(%rax), %rax
movq %rax, -0x58(%rbp)
movl $0xffffffff, -0x24(%rbp) # imm = 0xFFFFFFFF
leaq -0x25(%rbp), %rdi
movq %rdi, -0x50(%rbp)
callq 0x4130
movq -0x58(%rbp), %rsi
movq -0x50(%rbp), %rcx
leaq -0x20(%rbp), %rdi
leaq -0x24(%rbp), %rdx
callq 0xa5d0
jmp 0x8dbd
leaq -0x25(%rbp), %rdi
callq 0x7290
movl $0x0, -0x38(%rbp)
movq -0x60(%rbp), %rcx
movl -0x38(%rbp), %eax
cmpl 0xb0(%rcx), %eax
jge 0x8e28
movq -0x60(%rbp), %rdi
addq $0xb8, %rdi
movslq -0x38(%rbp), %rsi
callq 0x3ab0
movslq (%rax), %rsi
leaq -0x20(%rbp), %rdi
callq 0x3ab0
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movl -0x38(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x38(%rbp)
jmp 0x8dcd
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x25(%rbp), %rdi
callq 0x7290
jmp 0x8f43
movl $0x0, -0x3c(%rbp)
movl $0x0, -0x40(%rbp)
movq -0x60(%rbp), %rcx
movl -0x40(%rbp), %eax
cmpl 0xb0(%rcx), %eax
jge 0x8e82
movslq -0x40(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x3ab0
cmpl $-0x1, (%rax)
je 0x8e75
movl -0x3c(%rbp), %eax
movl %eax, -0x64(%rbp)
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
movslq -0x40(%rbp), %rsi
leaq -0x20(%rbp), %rdi
callq 0x3ab0
movl -0x64(%rbp), %ecx
movl %ecx, (%rax)
jmp 0x8e77
movl -0x40(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x40(%rbp)
jmp 0x8e36
movl $0x0, -0x44(%rbp)
movq -0x60(%rbp), %rcx
movl -0x44(%rbp), %eax
cmpl 0xb0(%rcx), %eax
jge 0x8f31
movl -0x44(%rbp), %esi
movq 0x1712a(%rip), %rdi     # 0x1ffd0
callq 0x22f0
movq %rax, -0x70(%rbp)
jmp 0x8eb1
movq -0x70(%rbp), %rdi
leaq 0xc7eb(%rip), %rsi      # 0x156a7
callq 0x2190
movq %rax, -0x78(%rbp)
jmp 0x8ec7
movq -0x60(%rbp), %rdi
addq $0xb8, %rdi
movslq -0x44(%rbp), %rsi
callq 0x3ab0
movslq (%rax), %rsi
leaq -0x20(%rbp), %rdi
callq 0x3ab0
movq -0x78(%rbp), %rdi
movl (%rax), %esi
callq 0x22f0
movq %rax, -0x80(%rbp)
jmp 0x8ef8
movq -0x80(%rbp), %rdi
movq 0x170bd(%rip), %rsi     # 0x1ffc0
callq 0x21d0
jmp 0x8f0a
jmp 0x8f0c
movl -0x44(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x44(%rbp)
jmp 0x8e89
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x20(%rbp), %rdi
callq 0x3640
jmp 0x8f43
leaq -0x20(%rbp), %rdi
callq 0x3640
addq $0x80, %rsp
popq %rbp
retq
movq -0x30(%rbp), %rdi
callq 0x2300
nopl (%rax)
// File: riyadparvez[P]louvain-method/./graph_binary.h
// Function: Graph::nb_selfloops(unsigned int)
inline double
Graph::nb_selfloops(unsigned int node) {
  assert(node>=0 && node<nb_nodes);

  pair<vector<unsigned int>::iterator, vector<float>::iterator > p = neighbors(node);
  for (unsigned int i=0 ; i<nb_neighbors(node) ; i++) {
    if (*(p.first+i)==node) {
      if (weights.size()!=0)
	return (double)*(p.second+i);
      else 
	return 1.;
    }
  }
  return 0.;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
xorl %eax, %eax
cmpl $0x0, -0x14(%rbp)
movb %al, -0x41(%rbp)
jb 0xa1a1
movq -0x50(%rbp), %rcx
movl -0x14(%rbp), %eax
cmpl (%rcx), %eax
setb %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0xa1aa
jmp 0xa1ac
jmp 0xa1cb
leaq 0xaeac(%rip), %rdi      # 0x1505f
leaq 0xaebe(%rip), %rsi      # 0x15078
movl $0x64, %edx
leaq 0xafd4(%rip), %rcx      # 0x1519a
callq 0x2110
movq -0x50(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x3ad0
movq %rax, -0x28(%rbp)
movq %rdx, -0x20(%rbp)
movl $0x0, -0x2c(%rbp)
movq -0x50(%rbp), %rdi
movl -0x2c(%rbp), %eax
movl %eax, -0x54(%rbp)
movl -0x14(%rbp), %esi
callq 0x3c80
movl %eax, %ecx
movl -0x54(%rbp), %eax
cmpl %ecx, %eax
jae 0xa287
leaq -0x28(%rbp), %rdi
movl -0x2c(%rbp), %eax
movl %eax, %esi
callq 0x3d40
movq %rax, -0x38(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x3d80
movl (%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0xa277
movq -0x50(%rbp), %rdi
addq $0x60, %rdi
callq 0x3da0
cmpq $0x0, %rax
je 0xa268
leaq -0x28(%rbp), %rdi
addq $0x8, %rdi
movl -0x2c(%rbp), %eax
movl %eax, %esi
callq 0x3dc0
movq %rax, -0x40(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3e00
movss (%rax), %xmm0
cvtss2sd %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
jmp 0xa28f
movsd 0xaf18(%rip), %xmm0     # 0x15188
movsd %xmm0, -0x8(%rbp)
jmp 0xa28f
jmp 0xa279
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0xa1e6
xorps %xmm0, %xmm0
movsd %xmm0, -0x8(%rbp)
movsd -0x8(%rbp), %xmm0
addq $0x60, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpl $0x0, -0xc(%rbp)
movb %al, -0x19(%rbp)
jl 0xa3cd
movq -0x28(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0xb0(%rcx), %eax
setl %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0xa3d6
jmp 0xa3d8
jmp 0xa3f7
leaq 0xade4(%rip), %rdi      # 0x151c3
leaq 0xadf2(%rip), %rsi      # 0x151d8
movl $0x68, %edx
leaq 0xadf4(%rip), %rcx      # 0x151e6
callq 0x2110
movq -0x28(%rbp), %rdi
addq $0x38, %rdi
movl -0xc(%rbp), %esi
callq 0x36a0
movq -0x28(%rbp), %rdi
movsd %xmm0, -0x40(%rbp)
addq $0xe8, %rdi
movslq -0x10(%rbp), %rsi
callq 0xa150
movsd -0x40(%rbp), %xmm1
movq -0x28(%rbp), %rdi
movsd (%rax), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rax)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x38(%rbp)
addq $0x38, %rdi
movl -0xc(%rbp), %esi
callq 0xa170
movq -0x28(%rbp), %rdi
movaps %xmm0, %xmm1
movsd -0x38(%rbp), %xmm0
addsd %xmm0, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x30(%rbp)
addq $0xd0, %rdi
movslq -0x10(%rbp), %rsi
callq 0xa150
movsd -0x30(%rbp), %xmm1
movq -0x28(%rbp), %rdi
movsd (%rax), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rax)
addq $0xb8, %rdi
movslq -0xc(%rbp), %rsi
callq 0x3ab0
movl $0xffffffff, (%rax)     # imm = 0xFFFFFFFF
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
xorl %eax, %eax
cmpl $0x0, -0xc(%rbp)
movb %al, -0x19(%rbp)
jl 0xa4ed
movq -0x28(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0xb0(%rcx), %eax
setl %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0xa4f6
jmp 0xa4f8
jmp 0xa517
leaq 0xacc4(%rip), %rdi      # 0x151c3
leaq 0xacd2(%rip), %rsi      # 0x151d8
movl $0x71, %edx
leaq 0xacfd(%rip), %rcx      # 0x1520f
callq 0x2110
movq -0x28(%rbp), %rdi
addq $0x38, %rdi
movl -0xc(%rbp), %esi
callq 0x36a0
movq -0x28(%rbp), %rdi
movsd %xmm0, -0x48(%rbp)
addq $0xe8, %rdi
movslq -0x10(%rbp), %rsi
callq 0xa150
movsd -0x48(%rbp), %xmm0
movq -0x28(%rbp), %rdi
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
addq $0x38, %rdi
movl -0xc(%rbp), %esi
callq 0xa170
movq -0x28(%rbp), %rdi
movaps %xmm0, %xmm1
movsd -0x40(%rbp), %xmm0
addsd %xmm0, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, -0x38(%rbp)
addq $0xd0, %rdi
movslq -0x10(%rbp), %rsi
callq 0xa150
movsd -0x38(%rbp), %xmm0
movq -0x28(%rbp), %rdi
addsd (%rax), %xmm0
movsd %xmm0, (%rax)
movl -0x10(%rbp), %eax
movl %eax, -0x2c(%rbp)
addq $0xb8, %rdi
movslq -0xc(%rbp), %rsi
callq 0x3ab0
movl -0x2c(%rbp), %ecx
movl %ecx, (%rax)
addq $0x50, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: riyadparvez[P]louvain-method/./community.h
// Function: Community::modularity_gain(int, int, double, double)
inline double
Community::modularity_gain(int node, int comm, double dnodecomm, double w_degree) {
  assert(node>=0 && node<size);

  double totc = (double)tot[comm];
  double degc = (double)w_degree;
  double m2   = (double)g.total_weight;
  double dnc  = (double)dnodecomm;
  
  return (dnc - totc*degc/m2);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movsd %xmm0, -0x18(%rbp)
movsd %xmm1, -0x20(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
xorl %eax, %eax
cmpl $0x0, -0xc(%rbp)
movb %al, -0x41(%rbp)
jl 0xabb2
movq -0x50(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0xb0(%rcx), %eax
setl %al
movb %al, -0x41(%rbp)
movb -0x41(%rbp), %al
testb $0x1, %al
jne 0xabbb
jmp 0xabbd
jmp 0xabdc
leaq 0xa5ff(%rip), %rdi      # 0x151c3
leaq 0xa60d(%rip), %rsi      # 0x151d8
movl $0x7a, %edx
leaq 0xa661(%rip), %rcx      # 0x15238
callq 0x2110
movq -0x50(%rbp), %rdi
addq $0xe8, %rdi
movslq -0x10(%rbp), %rsi
callq 0xa150
movq %rax, %rcx
movq -0x50(%rbp), %rax
movsd (%rcx), %xmm0
movsd %xmm0, -0x28(%rbp)
movsd -0x20(%rbp), %xmm0
movsd %xmm0, -0x30(%rbp)
movsd 0x48(%rax), %xmm0
movsd %xmm0, -0x38(%rbp)
movsd -0x18(%rbp), %xmm0
movsd %xmm0, -0x40(%rbp)
movsd -0x40(%rbp), %xmm0
movsd -0x28(%rbp), %xmm1
mulsd -0x30(%rbp), %xmm1
divsd -0x38(%rbp), %xmm1
subsd %xmm1, %xmm0
addq $0x50, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
callq 0x2060
movl $0x14, %ecx
cltd
idivl %ecx
addl $0x2, %edx
cvtsi2ss %edx, %xmm0
movss %xmm0, -0xc(%rbp)
movq 0x3a54(%rip), %rdi      # 0x5fd8
leaq 0x1a87(%rip), %rsi      # 0x4012
callq 0x2140
movq -0x18(%rbp), %rsi
movq %rax, %rdi
addq $0x20, %rsi
callq 0x2110
movq %rax, %rdi
leaq 0x1a6a(%rip), %rsi      # 0x4014
callq 0x2140
movq -0x18(%rbp), %rsi
movq %rax, %rdi
callq 0x2110
movq %rax, %rdi
leaq 0x1a52(%rip), %rsi      # 0x4017
callq 0x2140
movq 0x3a07(%rip), %rdi      # 0x5fd8
leaq 0x1a43(%rip), %rsi      # 0x401b
callq 0x2140
movl $0x0, -0x10(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x1c(%rbp)
callq 0x2060
movl $0x14, %ecx
cltd
idivl %ecx
movl -0x1c(%rbp), %eax
addl $0x2, %edx
cmpl %edx, %eax
jge 0x261f
movq 0x39d0(%rip), %rdi      # 0x5fd8
leaq 0x1a0e(%rip), %rsi      # 0x401d
callq 0x2140
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x25e4
movq 0x39b2(%rip), %rdi      # 0x5fd8
leaq 0x19f2(%rip), %rsi      # 0x401f
callq 0x2140
movq %rax, %rdi
movq 0x398c(%rip), %rsi      # 0x5fc8
callq 0x2170
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rsi, -0x70(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x80(%rbp)
addq $0x10, %rdi
movq %rdi, -0x78(%rbp)
callq 0x21d0
movq -0x80(%rbp), %rax
movq -0x78(%rbp), %rdi
movq -0x70(%rbp), %rsi
movl -0x14(%rbp), %ecx
movl %ecx, 0x8(%rax)
callq 0x2040
jmp 0x2a38
movslq -0x14(%rbp), %rax
movq %rax, -0x98(%rbp)
movl $0x40, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
addq $0x8, %rdi
movq $-0x1, %rax
cmovbq %rax, %rdi
testb %cl, %cl
cmovneq %rax, %rdi
movq %rdi, -0x90(%rbp)
callq 0x2030
movq %rax, -0x88(%rbp)
jmp 0x2a7b
movq -0x98(%rbp), %rax
movq -0x88(%rbp), %rcx
movq %rax, (%rcx)
addq $0x8, %rcx
movq %rcx, -0xa0(%rbp)
cmpq $0x0, %rax
je 0x2af6
movq -0xa0(%rbp), %rax
movq -0x98(%rbp), %rdx
shlq $0x6, %rdx
movq %rax, %rcx
addq %rdx, %rcx
movq %rcx, -0xb0(%rbp)
movq %rax, -0xa8(%rbp)
movq -0xa8(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x2490
jmp 0x2ad8
movq -0xb0(%rbp), %rcx
movq -0xb8(%rbp), %rax
addq $0x40, %rax
cmpq %rcx, %rax
movq %rax, -0xa8(%rbp)
jne 0x2ac3
movq -0x80(%rbp), %rax
movq -0xa0(%rbp), %rcx
movq %rcx, (%rax)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x2c50
movq -0x70(%rbp), %rsi
movq -0x80(%rbp), %rax
movq (%rax), %rax
movslq -0x28(%rbp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq %rax, -0xc0(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x2090
jmp 0x2b3f
movq -0xc0(%rbp), %rdi
leaq -0x48(%rbp), %rsi
callq 0x2650
jmp 0x2b51
leaq -0x48(%rbp), %rdi
callq 0x20b0
movq -0x80(%rbp), %rsi
movq (%rsi), %rax
movslq -0x28(%rbp), %rcx
shlq $0x6, %rcx
addq %rcx, %rax
movq %rax, -0xc8(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x2c70
jmp 0x2b7e
movq -0xc8(%rbp), %rdi
leaq -0x68(%rbp), %rsi
callq 0x2670
jmp 0x2b90
leaq -0x68(%rbp), %rdi
callq 0x20b0
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x2b0b
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
jmp 0x2c59
movq -0xa0(%rbp), %rcx
movq %rax, %rsi
movq -0xb8(%rbp), %rax
movq %rsi, -0x20(%rbp)
movl %edx, -0x24(%rbp)
cmpq %rax, %rcx
movq %rax, -0xd0(%rbp)
je 0x2c0d
movq -0xd0(%rbp), %rdi
addq $-0x40, %rdi
movq %rdi, -0xd8(%rbp)
callq 0x34d0
movq -0xa0(%rbp), %rcx
movq -0xd8(%rbp), %rax
cmpq %rcx, %rax
movq %rax, -0xd0(%rbp)
jne 0x2bdc
movq -0x90(%rbp), %rsi
movq -0x88(%rbp), %rdi
callq 0x2240
jmp 0x2c59
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x48(%rbp), %rdi
callq 0x20b0
jmp 0x2c59
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x20b0
jmp 0x2c59
addq $0xe0, %rsp
popq %rbp
retq
movq -0x78(%rbp), %rdi
callq 0x20b0
movq -0x20(%rbp), %rdi
callq 0x2210
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movl $0x0, -0x4(%rbp)
xorl %eax, %eax
movl %eax, %edi
callq 0x2120
movl %eax, %edi
callq 0x2130
movl $0x30, %edi
callq 0x2150
movq %rax, -0x88(%rbp)
movb $0x1, -0x4d(%rbp)
leaq -0x39(%rbp), %rdi
movq %rdi, -0x80(%rbp)
callq 0x2220
movq -0x80(%rbp), %rdx
leaq 0xb4c(%rip), %rsi       # 0x409b
leaq -0x38(%rbp), %rdi
callq 0x26a0
jmp 0x355a
movq -0x88(%rbp), %rdi
leaq -0x38(%rbp), %rsi
movl $0x5, %edx
callq 0x29f0
jmp 0x3571
movq -0x88(%rbp), %rax
movb $0x0, -0x4d(%rbp)
movq %rax, -0x10(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x20b0
leaq -0x39(%rbp), %rdi
callq 0x2190
movl $0x30, %edi
callq 0x2150
movq %rax, -0x98(%rbp)
movb $0x1, -0x72(%rbp)
leaq -0x71(%rbp), %rdi
movq %rdi, -0x90(%rbp)
callq 0x2220
movq -0x90(%rbp), %rdx
leaq 0xadb(%rip), %rsi       # 0x40a0
leaq -0x70(%rbp), %rdi
callq 0x26a0
jmp 0x35d0
movq -0x98(%rbp), %rdi
leaq -0x70(%rbp), %rsi
movl $0xa, %edx
callq 0x29f0
jmp 0x35e7
movq -0x98(%rbp), %rax
movb $0x0, -0x72(%rbp)
movq %rax, -0x18(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x20b0
leaq -0x71(%rbp), %rdi
callq 0x2190
movq 0x29c9(%rip), %rdi      # 0x5fd8
leaq 0xa8f(%rip), %rsi       # 0x40a5
callq 0x2140
movq %rax, %rdi
movq 0x29a3(%rip), %rsi      # 0x5fc8
callq 0x2170
movq -0x10(%rbp), %rdi
callq 0x3390
movq 0x299e(%rip), %rdi      # 0x5fd8
leaq 0xa6f(%rip), %rsi       # 0x40b0
callq 0x2140
movq %rax, %rdi
movq 0x2978(%rip), %rsi      # 0x5fc8
callq 0x2170
movq -0x18(%rbp), %rdi
callq 0x3390
movq -0x18(%rbp), %rax
movq %rax, -0xa0(%rbp)
cmpq $0x0, %rax
je 0x368c
movq -0xa0(%rbp), %rdi
callq 0x32f0
movq -0xa0(%rbp), %rdi
movl $0x30, %esi
callq 0x2160
movq -0x10(%rbp), %rax
movq %rax, -0xa8(%rbp)
cmpq $0x0, %rax
je 0x36ba
movq -0xa8(%rbp), %rdi
callq 0x32f0
movq -0xa8(%rbp), %rdi
movl $0x30, %esi
callq 0x2160
movl -0x4(%rbp), %eax
addq $0xb0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x36e9
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x20b0
leaq -0x39(%rbp), %rdi
callq 0x2190
testb $0x1, -0x4d(%rbp)
jne 0x36fa
jmp 0x370b
movq -0x88(%rbp), %rdi
movl $0x30, %esi
callq 0x2160
jmp 0x3754
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
jmp 0x3730
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x48(%rbp)
movl %eax, -0x4c(%rbp)
leaq -0x70(%rbp), %rdi
callq 0x20b0
leaq -0x71(%rbp), %rdi
callq 0x2190
testb $0x1, -0x72(%rbp)
jne 0x3741
jmp 0x3752
movq -0x98(%rbp), %rdi
movl $0x30, %esi
callq 0x2160
jmp 0x3754
movq -0x48(%rbp), %rdi
callq 0x2210
// File: 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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x30(%rbp)
movw -0xa(%rbp), %ax
movw %ax, -0x18(%rbp)
movl -0x10(%rbp), %eax
movl %eax, -0x14(%rbp)
addq $0x38, %rdi
leaq -0x18(%rbp), %rsi
callq 0x3680
movq -0x30(%rbp), %rdi
addq $0x50, %rdi
callq 0x36f0
testb $0x1, %al
jne 0x25e0
movq -0x30(%rbp), %rdi
addq $0x50, %rdi
callq 0x3730
movl %eax, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x25de
movq -0x30(%rbp), %rdi
addq $0x50, %rdi
movslq -0x20(%rbp), %rsi
callq 0x3750
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x25b1
jmp 0x25e0
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
callq 0x3770
testb $0x1, %al
jne 0x2635
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
callq 0x37b0
movl %eax, -0x24(%rbp)
movl $0x0, -0x28(%rbp)
movl -0x28(%rbp), %eax
cmpl -0x24(%rbp), %eax
jge 0x2633
movq -0x30(%rbp), %rdi
addq $0x8, %rdi
movslq -0x28(%rbp), %rsi
callq 0x37d0
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
movl -0x28(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x28(%rbp)
jmp 0x2608
jmp 0x2635
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x120, %rsp            # imm = 0x120
movq %rsi, -0xd0(%rbp)
movq %rdi, -0x10(%rbp)
movq %rsi, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0xc8(%rbp)
movq 0x68(%rax), %rax
movq %rax, -0xc0(%rbp)
leaq -0x38(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x2100
movq -0xc0(%rbp), %rdi
movq -0xb8(%rbp), %rsi
callq 0xa1f0
movb %al, -0xa9(%rbp)
jmp 0x274b
movb -0xa9(%rbp), %al
movsbl %al, %eax
movl %eax, -0xd4(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x2160
movl -0xd4(%rbp), %eax
testl %eax, %eax
je 0x27ae
jmp 0x276f
movl -0xd4(%rbp), %eax
subl $0x1, %eax
je 0x2837
jmp 0x2780
movl -0xd4(%rbp), %eax
subl $0x2, %eax
je 0x28c9
jmp 0x2955
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x38(%rbp), %rdi
callq 0x2160
jmp 0x2963
movq -0xd0(%rbp), %rsi
movq -0xc8(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0xe8(%rbp)
leaq -0x68(%rbp), %rdi
movq %rdi, -0xe0(%rbp)
callq 0x2100
movq -0xe8(%rbp), %rdi
movq -0xe0(%rbp), %rsi
callq 0xa370
movl %eax, -0xd8(%rbp)
jmp 0x27f2
movl -0xd8(%rbp), %edx
movq -0xc8(%rbp), %rdi
movl $0x1, %esi
callq 0x2550
jmp 0x280b
leaq -0x68(%rbp), %rdi
callq 0x2160
movb $0x0, -0x1(%rbp)
jmp 0x2957
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x68(%rbp), %rdi
callq 0x2160
jmp 0x2963
movq -0xd0(%rbp), %rsi
movq -0xc8(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x100(%rbp)
leaq -0x88(%rbp), %rdi
movq %rdi, -0xf8(%rbp)
callq 0x2100
movq -0x100(%rbp), %rdi
movq -0xf8(%rbp), %rsi
callq 0xa370
movl %eax, -0xec(%rbp)
jmp 0x287e
movl -0xec(%rbp), %edx
movq -0xc8(%rbp), %rdi
movl $0x2, %esi
callq 0x2550
jmp 0x2897
leaq -0x88(%rbp), %rdi
callq 0x2160
movb $0x1, -0x1(%rbp)
jmp 0x2957
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x88(%rbp), %rdi
callq 0x2160
jmp 0x2963
movq -0xd0(%rbp), %rsi
movq -0xc8(%rbp), %rax
movq 0x68(%rax), %rax
movq %rax, -0x118(%rbp)
leaq -0xa8(%rbp), %rdi
movq %rdi, -0x110(%rbp)
callq 0x2100
movq -0x118(%rbp), %rdi
movq -0x110(%rbp), %rsi
callq 0xa370
movl %eax, -0x104(%rbp)
jmp 0x2910
movl -0x104(%rbp), %edx
movq -0xc8(%rbp), %rdi
movl $0x3, %esi
callq 0x2550
jmp 0x2929
leaq -0xa8(%rbp), %rdi
callq 0x2160
movb $0x2, -0x1(%rbp)
jmp 0x2957
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0xa8(%rbp), %rdi
callq 0x2160
jmp 0x2963
ud2
movb -0x1(%rbp), %al
addq $0x120, %rsp            # imm = 0x120
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x2390
nopl (%rax)
// File: 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
movq %rsp, %rbp
subq $0x60, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x50(%rbp)
movsbl -0x9(%rbp), %eax
cmpl $0x1, %eax
jne 0x2d2b
movq -0x50(%rbp), %rdi
xorl %esi, %esi
movl $0xffffffff, %edx       # imm = 0xFFFFFFFF
callq 0x2550
movq -0x50(%rbp), %rdi
movl $0x9, %esi
xorl %edx, %edx
callq 0x2550
movb $0x1, %al
addq $0x60, %rsp
popq %rbp
retq
movb $0x1, -0x45(%rbp)
movl $0x20, %edi
callq 0x2120
movq %rax, -0x60(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x58(%rbp)
callq 0x23a0
movq -0x58(%rbp), %rdx
leaq 0xb2ec(%rip), %rsi      # 0xe041
leaq -0x30(%rbp), %rdi
callq 0x3880
jmp 0x2d60
movq -0x60(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x6400
jmp 0x2d6f
movq -0x60(%rbp), %rdi
movb $0x0, -0x45(%rbp)
leaq 0x12032(%rip), %rsi     # 0x14db0
leaq 0xbab(%rip), %rdx       # 0x3930
callq 0x2370
jmp 0x2dd4
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x2daf
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2160
leaq -0x31(%rbp), %rdi
callq 0x2270
testb $0x1, -0x45(%rbp)
jne 0x2dc0
jmp 0x2dc9
movq -0x60(%rbp), %rdi
callq 0x21b0
jmp 0x2dcb
movq -0x40(%rbp), %rdi
callq 0x2390
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x70, %rsp
movb %sil, %al
movq %rdi, -0x8(%rbp)
movb %al, -0x9(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x58(%rbp)
movsbl -0x9(%rbp), %eax
movl %eax, -0x4c(%rbp)
subl $0x1, %eax
je 0x3202
jmp 0x31f8
movl -0x4c(%rbp), %eax
subl $0x2, %eax
je 0x3217
jmp 0x322c
movq -0x58(%rbp), %rdi
movl $0xe, %esi
xorl %edx, %edx
callq 0x2550
jmp 0x32cc
movq -0x58(%rbp), %rdi
movl $0xf, %esi
xorl %edx, %edx
callq 0x2550
jmp 0x32cc
movb $0x1, -0x45(%rbp)
movl $0x20, %edi
callq 0x2120
movq %rax, -0x68(%rbp)
leaq -0x31(%rbp), %rdi
movq %rdi, -0x60(%rbp)
callq 0x23a0
movq -0x60(%rbp), %rdx
leaq 0xae58(%rip), %rsi      # 0xe0ae
leaq -0x30(%rbp), %rdi
callq 0x3880
jmp 0x3261
movq -0x68(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x6400
jmp 0x3270
movq -0x68(%rbp), %rdi
movb $0x0, -0x45(%rbp)
leaq 0x11b31(%rip), %rsi     # 0x14db0
leaq 0x6aa(%rip), %rdx       # 0x3930
callq 0x2370
jmp 0x32db
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
jmp 0x32b0
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x40(%rbp)
movl %eax, -0x44(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x2160
leaq -0x31(%rbp), %rdi
callq 0x2270
testb $0x1, -0x45(%rbp)
jne 0x32c1
jmp 0x32ca
movq -0x68(%rbp), %rdi
callq 0x21b0
jmp 0x32d2
addq $0x70, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
callq 0x2390
nopl (%rax,%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movl (%rdi), %eax
addl $0x1, %eax
movl %eax, (%rdi)
movl (%rdi), %edx
movl $0x11, %esi
callq 0x2550
movq -0x18(%rbp), %rdi
movl (%rdi), %eax
movl %eax, -0x10(%rbp)
movl $0x0, -0xc(%rbp)
addq $0x50, %rdi
leaq -0x10(%rbp), %rsi
callq 0x39f0
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: protonpopsicle[P]lang/src/compiler/ByteCoder.cpp
// Function: ByteCoder::land()
void ByteCoder::land() {
    Jump jump = activeJumps.back();
    activeJumps.pop_back();
    
    int len = ops.size();
    for (int i = len; i > 0; i--) {
        if (ops[i].opcode == OP_JUMP_IF_FALSE && ops[i].operand == jump.id) {
            ops[i].operand = jump.shift;
        }
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x20(%rbp)
addq $0x50, %rdi
callq 0x3a60
movq -0x20(%rbp), %rdi
movq (%rax), %rax
movq %rax, -0x10(%rbp)
addq $0x50, %rdi
callq 0x3aa0
movq -0x20(%rbp), %rdi
addq $0x38, %rdi
callq 0x3ad0
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
movl %eax, -0x18(%rbp)
cmpl $0x0, -0x18(%rbp)
jle 0x3459
movq -0x20(%rbp), %rdi
addq $0x38, %rdi
movslq -0x18(%rbp), %rsi
callq 0x3af0
movswl (%rax), %eax
cmpl $0x11, %eax
jne 0x344c
movq -0x20(%rbp), %rdi
addq $0x38, %rdi
movslq -0x18(%rbp), %rsi
callq 0x3af0
movl 0x4(%rax), %eax
cmpl -0x10(%rbp), %eax
jne 0x344c
movq -0x20(%rbp), %rdi
movl -0xc(%rbp), %eax
movl %eax, -0x24(%rbp)
addq $0x38, %rdi
movslq -0x18(%rbp), %rsi
callq 0x3af0
movl -0x24(%rbp), %ecx
movl %ecx, 0x4(%rax)
jmp 0x344e
movl -0x18(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x33f7
addq $0x30, %rsp
popq %rbp
retq
nop
// File: 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 %rbp
movq %rsp, %rbp
subq $0x50, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rdi
movq 0x68(%rax), %rax
movl 0x50(%rax), %edx
leaq 0xac50(%rip), %rsi      # 0xe0da
movb $0x0, %al
callq 0x2300
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x68(%rax), %rax
movl 0x54(%rax), %edx
leaq 0xac33(%rip), %rsi      # 0xe0da
movb $0x0, %al
callq 0x2300
movq -0x28(%rbp), %rax
movq -0x10(%rbp), %rdi
movq 0x68(%rax), %rax
movl 0x58(%rax), %edx
leaq 0xac16(%rip), %rsi      # 0xe0da
movb $0x0, %al
callq 0x2300
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
addq $0x20, %rdi
callq 0x3860
movq -0x38(%rbp), %rdi
movq %rax, %rdx
leaq 0xabec(%rip), %rsi      # 0xe0da
movb $0x0, %al
callq 0x2300
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
addq $0x38, %rdi
callq 0x3ad0
movq -0x30(%rbp), %rdi
movq %rax, %rdx
leaq 0xabb7(%rip), %rsi      # 0xe0cf
movb $0x0, %al
callq 0x2300
movq -0x28(%rbp), %rdi
addq $0x20, %rdi
callq 0x3860
movl %eax, -0x14(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x357f
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x40(%rbp)
addq $0x20, %rdi
movslq -0x18(%rbp), %rsi
callq 0x3b10
movq %rax, %rdi
callq 0x20f0
movq -0x40(%rbp), %rdi
movq %rax, %rdx
leaq 0xab66(%rip), %rsi      # 0xe0d3
movb $0x0, %al
callq 0x2300
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x3536
movq -0x28(%rbp), %rdi
addq $0x38, %rdi
callq 0x3ad0
movl %eax, -0x14(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x35f1
movq -0x28(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, -0x50(%rbp)
addq $0x38, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x3af0
movq -0x28(%rbp), %rdi
movswl (%rax), %eax
movl %eax, -0x44(%rbp)
addq $0x38, %rdi
movslq -0x1c(%rbp), %rsi
callq 0x3af0
movq -0x50(%rbp), %rdi
movl -0x44(%rbp), %edx
movl 0x4(%rax), %ecx
leaq 0xaaf8(%rip), %rsi      # 0xe0d7
movb $0x0, %al
callq 0x2300
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3596
addq $0x50, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: protonpopsicle[P]lang/src/compiler/Lexer.cpp
// Function: Lexer::read(char)
bool Lexer::read(char c) {
    read();
    if (peek != c) {
        return false;
    }
    peek = ' '; // clear peek
    return true; 
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movb %sil, %al
movq %rdi, -0x10(%rbp)
movb %al, -0x11(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0x20(%rbp)
callq 0x74f0
movq -0x20(%rbp), %rax
movzbl 0x38(%rax), %eax
movsbl -0x11(%rbp), %ecx
cmpl %ecx, %eax
je 0x7555
movb $0x0, -0x1(%rbp)
jmp 0x7561
movq -0x20(%rbp), %rax
movb $0x20, 0x38(%rax)
movb $0x1, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: 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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x38(%rbp)
addq $0x18, %rdi
movq %rdi, -0x40(%rbp)
callq 0x9cd0
movq -0x38(%rbp), %rdi
movq -0x10(%rbp), %rax
movq %rax, (%rdi)
movq -0x18(%rbp), %rax
movq %rax, 0x8(%rdi)
movq -0x20(%rbp), %rax
movq %rax, 0x10(%rdi)
callq 0x8e50
jmp 0x8e1f
addq $0x40, %rsp
popq %rbp
retq
movq -0x40(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x28(%rbp)
movl %eax, -0x2c(%rbp)
callq 0x9c70
movq -0x28(%rbp), %rdi
callq 0x2390
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x30, %rsp
movw %si, %ax
movq %rdi, -0x8(%rbp)
movw %ax, -0xa(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movswl 0x18(%rax), %eax
movswl -0xa(%rbp), %ecx
cmpl %ecx, %eax
jne 0x8ec2
movq -0x28(%rbp), %rdi
callq 0x8e50
jmp 0x8f17
movl $0x20, %edi
callq 0x2120
movq %rax, %rdi
movq -0x28(%rbp), %rax
movq %rdi, %rcx
movq %rcx, -0x30(%rbp)
movswl -0xa(%rbp), %esi
movswl 0x18(%rax), %edx
callq 0x6460
jmp 0x8ee9
movq -0x30(%rbp), %rdi
leaq 0xbebc(%rip), %rsi      # 0x14db0
leaq -0x55cb(%rip), %rdx     # 0x3930
callq 0x2370
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x18(%rbp)
movl %eax, -0x1c(%rbp)
callq 0x21b0
jmp 0x8f1d
addq $0x30, %rsp
popq %rbp
retq
movq -0x18(%rbp), %rdi
callq 0x2390
nopw %cs:(%rax,%rax)
// File: protonpopsicle[P]lang/src/compiler/Parser.cpp
// Function: Parser::block()
void Parser::block() {
    match('{');
    zoneMgr->saveZone();
    zoneMgr->createZone();
    stmts();
    match('}');
    zoneMgr->loadZone();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x10(%rbp)
movl $0x7b, %esi
callq 0x8e90
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x9ef0
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x9eb0
movq -0x10(%rbp), %rdi
callq 0x8fc0
movq -0x10(%rbp), %rdi
movl $0x7d, %esi
callq 0x8e90
movq -0x10(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x9f10
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0xe0, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rsi
movq %rsi, -0xc8(%rbp)
addq $0x20, %rsi
leaq -0x28(%rbp), %rdi
callq 0x2100
movq -0xc8(%rbp), %rdi
callq 0x8e50
jmp 0x9365
movq -0xc8(%rbp), %rsi
addq $0x20, %rsi
leaq -0x58(%rbp), %rdi
callq 0x2100
jmp 0x937b
movq -0xc8(%rbp), %rdi
movl $0x102, %esi            # imm = 0x102
callq 0x8e90
jmp 0x938e
movq -0xc8(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0xd0(%rbp)
leaq -0x78(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x2100
jmp 0x93af
leaq -0x98(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0x2100
jmp 0x93c1
movq -0xd0(%rbp), %rdi
leaq -0x78(%rbp), %rsi
leaq -0x98(%rbp), %rdx
callq 0x9f30
jmp 0x93da
leaq -0x98(%rbp), %rdi
callq 0x2160
leaq -0x78(%rbp), %rdi
callq 0x2160
movq -0xc8(%rbp), %rax
movswl 0x18(%rax), %eax
cmpl $0x3d, %eax
jne 0x94eb
movq -0xc8(%rbp), %rdi
movl $0x3d, %esi
callq 0x8e90
jmp 0x9416
movq -0xc8(%rbp), %rdi
callq 0x9530
movb %al, -0xd1(%rbp)
jmp 0x942a
movq -0xc8(%rbp), %rax
movb -0xd1(%rbp), %cl
movb %cl, -0x99(%rbp)
movq 0x10(%rax), %rax
movq %rax, -0xe0(%rbp)
leaq -0xc0(%rbp), %rdi
leaq -0x58(%rbp), %rsi
callq 0x2100
jmp 0x945a
movq -0xe0(%rbp), %rdi
movsbl -0x99(%rbp), %edx
leaq -0xc0(%rbp), %rsi
callq 0x2970
jmp 0x9476
leaq -0xc0(%rbp), %rdi
callq 0x2160
jmp 0x94eb
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x950f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x9506
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
jmp 0x94c6
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0x98(%rbp), %rdi
callq 0x2160
leaq -0x78(%rbp), %rdi
callq 0x2160
jmp 0x9506
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x30(%rbp)
movl %eax, -0x34(%rbp)
leaq -0xc0(%rbp), %rdi
callq 0x2160
jmp 0x9506
leaq -0x58(%rbp), %rdi
callq 0x2160
leaq -0x28(%rbp), %rdi
callq 0x2160
addq $0xe0, %rsp
popq %rbp
retq
leaq -0x58(%rbp), %rdi
callq 0x2160
leaq -0x28(%rbp), %rdi
callq 0x2160
movq -0x30(%rbp), %rdi
callq 0x2390
nopw %cs:(%rax,%rax)
// File: 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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x95a0
movb %al, -0x9(%rbp)
movq -0x18(%rbp), %rax
movswl 0x18(%rax), %eax
cmpl $0x131, %eax            # imm = 0x131
jne 0x9593
movq -0x18(%rbp), %rdi
callq 0x8e50
movq -0x18(%rbp), %rdi
callq 0x95a0
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, -0xa(%rbp)
movq 0x10(%rax), %rdi
movb -0x9(%rbp), %al
movl $0x131, %esi            # imm = 0x131
movsbl %al, %edx
movsbl -0xa(%rbp), %ecx
callq 0x2fc0
movb %al, -0x9(%rbp)
jmp 0x954c
movb -0x9(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: protonpopsicle[P]lang/src/compiler/Parser.cpp
// Function: Parser::join()
char Parser::join() {
    char lhs, rhs;
    lhs = equality(); // join -> equality restJoin
    
    // restJoin -> && equality restJoin
    while (look.tag == AND) {
        move();
        rhs = equality();
        lhs = byteCoder->evalBool(AND, lhs, rhs);
    }
    // restJoin -> e
    return lhs;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x9610
movb %al, -0x9(%rbp)
movq -0x18(%rbp), %rax
movswl 0x18(%rax), %eax
cmpl $0x130, %eax            # imm = 0x130
jne 0x9603
movq -0x18(%rbp), %rdi
callq 0x8e50
movq -0x18(%rbp), %rdi
callq 0x9610
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, -0xa(%rbp)
movq 0x10(%rax), %rdi
movb -0x9(%rbp), %al
movl $0x130, %esi            # imm = 0x130
movsbl %al, %edx
movsbl -0xa(%rbp), %ecx
callq 0x2fc0
movb %al, -0x9(%rbp)
jmp 0x95bc
movb -0x9(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: protonpopsicle[P]lang/src/compiler/Parser.cpp
// Function: Parser::equality()
char Parser::equality() {
    short oper;
    char lhs, rhs;
    lhs = rel(); // equality -> rel restEquality
    
    // restEquality -> == rel restEquality | != rel restEquality
    while (look.tag == EQ || look.tag == NE) {
        oper = look.tag;
        move();
        rhs = rel();
        lhs = byteCoder->evalBool(oper, lhs, rhs);
    }
    // restEquality -> e
    return lhs;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
callq 0x96b0
movb %al, -0xb(%rbp)
movq -0x18(%rbp), %rax
movswl 0x18(%rax), %ecx
movb $0x1, %al
cmpl $0x12e, %ecx            # imm = 0x12E
movb %al, -0x19(%rbp)
je 0x9654
movq -0x18(%rbp), %rax
movswl 0x18(%rax), %eax
cmpl $0x12f, %eax            # imm = 0x12F
sete %al
movb %al, -0x19(%rbp)
movb -0x19(%rbp), %al
testb $0x1, %al
jne 0x965d
jmp 0x969f
movq -0x18(%rbp), %rdi
movw 0x18(%rdi), %ax
movw %ax, -0xa(%rbp)
callq 0x8e50
movq -0x18(%rbp), %rdi
callq 0x96b0
movb %al, %cl
movq -0x18(%rbp), %rax
movb %cl, -0xc(%rbp)
movq 0x10(%rax), %rdi
movw -0xa(%rbp), %cx
movb -0xb(%rbp), %al
movswl %cx, %esi
movsbl %al, %edx
movsbl -0xc(%rbp), %ecx
callq 0x2fc0
movb %al, -0xb(%rbp)
jmp 0x962c
movb -0xb(%rbp), %al
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax,%rax)