LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O2/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x210, %rsp            # imm = 0x210
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x8(%rsp), %r15
movq %r15, %rdi
callq 0x21c0
pushq $0x8
popq %rdx
movq %r15, %rdi
movq %r14, %rsi
callq 0x20e0
leaq 0x8(%rsp), %r14
movq %rsp, %r15
leaq 0x4(%rsp), %r12
movq 0x8(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x28(%rsp,%rax)
jne 0x3d8d
movq %r14, %rdi
movq %r15, %rsi
callq 0x22e0
movq %rax, %rdi
movq %r12, %rsi
callq 0x22e0
movq 0x8(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x28(%rsp,%rax)
jne 0x3cd0
movl (%rsp), %esi
movq 0xb8(%rbx), %rax
movslq (%rax,%rsi,4), %r13
movq %rbx, %rdi
callq 0x3dd0
movl (%rsp), %esi
movq (%rbx), %rax
movsd (%rax,%r13,8), %xmm0
movq %rbx, %rdi
movl %r13d, %edx
callq 0x4ae6
movl 0x30(%rbx), %eax
movq 0x18(%rbx), %rcx
movl 0x4(%rsp), %edx
xorl %r13d, %r13d
cmpq %r13, %rax
je 0x3d76
cmpl %edx, (%rcx,%r13,4)
je 0x3d55
incq %r13
jmp 0x3d45
movq (%rbx), %rax
cvtsd2ss (%rax,%rdx,8), %xmm0
movl (%rsp), %esi
cvtss2sd %xmm0, %xmm0
movq %rbx, %rdi
callq 0x4b92
cmpl %r13d, 0x30(%rbx)
jne 0x3cd0
movl (%rsp), %esi
movl 0x4(%rsp), %edx
xorps %xmm0, %xmm0
movq %rbx, %rdi
callq 0x4b92
jmp 0x3cd0
leaq 0x8(%rsp), %rdi
callq 0x2050
leaq 0x8(%rsp), %rdi
callq 0x2060
addq $0x210, %rsp            # imm = 0x210
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x3dba
jmp 0x3dba
jmp 0x3dba
jmp 0x3dba
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2060
movq %rbx, %rdi
callq 0x22f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl 0x30(%rdi), %eax
movq (%rdi), %rcx
movq 0x18(%rdi), %rdx
xorl %esi, %esi
movabsq $-0x4010000000000000, %rdi # imm = 0xBFF0000000000000
cmpq %rax, %rsi
jae 0x3e08
movl (%rdx,%rsi,4), %r8d
movq %rdi, (%rcx,%r8,8)
incq %rsi
jmp 0x3df6
andl $0x0, 0x30(%r14)
leaq 0x38(%r14), %r13
movq %r13, %rdi
movl %ebx, %esi
callq 0x2e22
movq %rax, %r15
movq %rdx, %r12
movq %r13, %rdi
movl %ebx, %esi
callq 0x2e7c
movl %ebx, %esi
movq 0x18(%r14), %rcx
movq 0xb8(%r14), %rdx
movl (%rdx,%rsi,4), %edi
movl %edi, (%rcx)
movq (%r14), %rsi
andq $0x0, (%rsi,%rdi,8)
movl $0x1, 0x30(%r14)
movq 0x98(%r14), %rdi
movq 0xa0(%r14), %r8
movl %eax, %eax
xorl %r9d, %r9d
movsd 0x3340(%rip), %xmm0     # 0x71a8
movsd 0x3340(%rip), %xmm1     # 0x71b0
cmpq %r9, %rax
je 0x3ec1
movaps %xmm0, %xmm2
cmpq %rdi, %r8
je 0x3e83
cvtss2sd (%r12,%r9,4), %xmm2
movl (%r15,%r9,4), %r10d
cmpl %ebx, %r10d
je 0x3ebc
movl (%rdx,%r10,4), %r10d
movsd (%rsi,%r10,8), %xmm3
ucomisd %xmm1, %xmm3
jne 0x3eb2
jp 0x3eb2
movl 0x30(%r14), %r11d
leal 0x1(%r11), %ebp
movl %ebp, 0x30(%r14)
movl %r10d, (%rcx,%r11,4)
xorpd %xmm3, %xmm3
addsd %xmm3, %xmm2
movsd %xmm2, (%rsi,%r10,8)
incq %r9
jmp 0x3e70
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O2/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:
movsd 0x48(%rdi), %xmm1
movl 0xb0(%rdi), %eax
movq 0xe8(%rdi), %rcx
movq 0xd0(%rdi), %rdx
xorl %esi, %esi
testl %eax, %eax
cmovlel %esi, %eax
xorpd %xmm2, %xmm2
xorpd %xmm0, %xmm0
cmpq %rsi, %rax
je 0x3fe8
movsd (%rcx,%rsi,8), %xmm3
ucomisd %xmm2, %xmm3
jbe 0x3fe3
movsd (%rdx,%rsi,8), %xmm4
divsd %xmm1, %xmm4
divsd %xmm1, %xmm3
mulsd %xmm3, %xmm3
subsd %xmm3, %xmm4
addsd %xmm4, %xmm0
incq %rsi
jmp 0x3fba
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/riyadparvez[P]louvain-method/community.cpp
// Function: Community::partition2graph()
void
Community::partition2graph() {
  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++) {
    pair<vector<unsigned int>::iterator, vector<float>::iterator> p = g.neighbors(i);

    int deg = g.nb_neighbors(i);
    for (int j=0 ; j<deg ; j++) {
      int neigh = *(p.first+j);
      cout << renumber[n2c[i]] << " " << renumber[n2c[neigh]] << endl;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movslq 0xb0(%rdi), %rsi
leaq 0x34(%rsp), %rdx
orl $-0x1, (%rdx)
leaq 0x18(%rsp), %r14
leaq 0xf(%rsp), %rcx
movq %r14, %rdi
callq 0x4c36
movq 0xb8(%rbx), %rcx
xorl %edx, %edx
movq (%r14), %rsi
movslq 0xb0(%rbx), %rax
cmpq %rax, %rdx
jge 0x4040
movslq (%rcx,%rdx,4), %rax
incl (%rsi,%rax,4)
incq %rdx
jmp 0x4028
xorl %ecx, %ecx
movq 0x18(%rsp), %rdx
xorl %esi, %esi
movslq %eax, %rdi
cmpq %rdi, %rcx
jge 0x4067
cmpl $-0x1, (%rdx,%rcx,4)
je 0x4062
movl %esi, (%rdx,%rcx,4)
incl %esi
movl 0xb0(%rbx), %eax
incq %rcx
jmp 0x4049
leaq 0x38(%rbx), %r14
xorl %r13d, %r13d
movq %r14, 0x10(%rsp)
cltq
cmpq %rax, %r13
jge 0x411b
movq %r14, %rdi
movl %r13d, %esi
callq 0x2e22
movq %rax, %rbp
movq %r14, %rdi
movl %r13d, %esi
callq 0x2e7c
movl %eax, %r14d
testl %eax, %eax
movl $0x0, %eax
cmovlel %eax, %r14d
xorl %r15d, %r15d
cmpq %r15, %r14
je 0x4108
movslq (%rbp,%r15,4), %r12
movq 0xb8(%rbx), %rax
movslq (%rax,%r13,4), %rax
movq 0x18(%rsp), %rcx
movl (%rcx,%rax,4), %esi
movq 0x6f04(%rip), %rdi      # 0xafd0
callq 0x22d0
movq %rax, %rdi
leaq 0x35ec(%rip), %rsi      # 0x76c7
callq 0x2180
movq 0xb8(%rbx), %rcx
movslq (%rcx,%r12,4), %rcx
movq 0x18(%rsp), %rdx
movl (%rdx,%rcx,4), %esi
movq %rax, %rdi
callq 0x22d0
movq %rax, %rdi
callq 0x20c0
incq %r15
jmp 0x40a8
incq %r13
movl 0xb0(%rbx), %eax
movq 0x10(%rsp), %r14
jmp 0x4073
leaq 0x18(%rsp), %rdi
callq 0x34f2
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x4136
movq %rax, %rbx
leaq 0x18(%rsp), %rdi
callq 0x34f2
movq %rbx, %rdi
callq 0x22f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movslq 0xb0(%rdi), %rsi
leaq 0xc(%rsp), %rdx
orl $-0x1, (%rdx)
leaq 0x10(%rsp), %r14
leaq 0xb(%rsp), %rcx
movq %r14, %rdi
callq 0x4c36
movq 0xb8(%rbx), %rcx
xorl %edx, %edx
movq (%r14), %rsi
movslq 0xb0(%rbx), %rax
cmpq %rax, %rdx
jge 0x419f
movslq (%rcx,%rdx,4), %rax
incl (%rsi,%rax,4)
incq %rdx
jmp 0x4187
xorl %ecx, %ecx
movq 0x10(%rsp), %rdx
xorl %esi, %esi
movslq %eax, %rdi
cmpq %rdi, %rcx
jge 0x41c6
cmpl $-0x1, (%rdx,%rcx,4)
je 0x41c1
movl %esi, (%rdx,%rcx,4)
incl %esi
movl 0xb0(%rbx), %eax
incq %rcx
jmp 0x41a8
xorl %r14d, %r14d
movq 0x6e00(%rip), %r15      # 0xafd0
leaq 0x34f0(%rip), %r12      # 0x76c7
cltq
cmpq %rax, %r14
jge 0x4222
movq %r15, %rdi
movl %r14d, %esi
callq 0x22d0
movq %rax, %rdi
movq %r12, %rsi
callq 0x2180
movq 0xb8(%rbx), %rcx
movslq (%rcx,%r14,4), %rcx
movq 0x10(%rsp), %rdx
movl (%rdx,%rcx,4), %esi
movq %rax, %rdi
callq 0x22d0
movq %rax, %rdi
callq 0x20c0
incq %r14
movl 0xb0(%rbx), %eax
jmp 0x41d7
leaq 0x10(%rsp), %rdi
callq 0x34f2
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %rbx
leaq 0x10(%rsp), %rdi
callq 0x34f2
movq %rbx, %rdi
callq 0x22f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
cmpl %esi, (%rdi)
jbe 0x4a6f
movl %esi, %ebp
movq %rdi, %rbx
callq 0x2e22
movq %rax, %r15
movq %rdx, %r14
xorl %r12d, %r12d
movq %rbx, %rdi
movl %ebp, %esi
callq 0x2e7c
movl %eax, %eax
cmpq %rax, %r12
jae 0x4a59
leaq 0x1(%r12), %rax
cmpl %ebp, (%r15,%r12,4)
movq %rax, %r12
jne 0x4a27
movq 0x68(%rbx), %rcx
cmpq 0x60(%rbx), %rcx
je 0x4a5e
cvtss2sd -0x4(%r14,%rax,4), %xmm0
jmp 0x4a66
xorps %xmm0, %xmm0
jmp 0x4a66
movsd 0x2742(%rip), %xmm0     # 0x71a8
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2605(%rip), %rdi      # 0x707b
leaq 0x2617(%rip), %rsi      # 0x7094
leaq 0x2736(%rip), %rcx      # 0x71ba
pushq $0x64
popq %rdx
callq 0x20f0
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movsd %xmm0, (%rsp)
testl %esi, %esi
js 0x4b74
movl %esi, %ebp
movq %rdi, %rbx
cmpl %esi, 0xb0(%rdi)
jle 0x4b74
movl %edx, %r14d
leaq 0x38(%rbx), %r15
movq %r15, %rdi
movl %ebp, %esi
callq 0x2cc0
movslq %r14d, %r14
movq 0xe8(%rbx), %rax
movsd (%rax,%r14,8), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, (%rax,%r14,8)
movq %r15, %rdi
movl %ebp, %esi
callq 0x4a08
movsd (%rsp), %xmm1
addsd %xmm1, %xmm1
addsd %xmm0, %xmm1
movq 0xd0(%rbx), %rax
movsd (%rax,%r14,8), %xmm0
subsd %xmm1, %xmm0
movsd %xmm0, (%rax,%r14,8)
movl %ebp, %eax
movq 0xb8(%rbx), %rcx
orl $-0x1, (%rcx,%rax,4)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x2668(%rip), %rdi      # 0x71e3
leaq 0x2676(%rip), %rsi      # 0x71f8
leaq 0x267d(%rip), %rcx      # 0x7206
pushq $0x68
popq %rdx
callq 0x20f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movsd %xmm0, (%rsp)
testl %esi, %esi
js 0x4c18
movl %esi, %ebp
movq %rdi, %rbx
cmpl %esi, 0xb0(%rdi)
jle 0x4c18
movl %edx, %r14d
leaq 0x38(%rbx), %r15
movq %r15, %rdi
movl %ebp, %esi
callq 0x2cc0
movslq %r14d, %r14
movq 0xe8(%rbx), %rax
addsd (%rax,%r14,8), %xmm0
movsd %xmm0, (%rax,%r14,8)
movq %r15, %rdi
movl %ebp, %esi
callq 0x4a08
movsd (%rsp), %xmm1
addsd %xmm1, %xmm1
addsd %xmm0, %xmm1
movq 0xd0(%rbx), %rax
addsd (%rax,%r14,8), %xmm1
movsd %xmm1, (%rax,%r14,8)
movl %ebp, %eax
movq 0xb8(%rbx), %rcx
movl %r14d, (%rcx,%rax,4)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x25c4(%rip), %rdi      # 0x71e3
leaq 0x25d2(%rip), %rsi      # 0x71f8
leaq 0x2602(%rip), %rcx      # 0x722f
pushq $0x71
popq %rdx
callq 0x20f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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:
testl %esi, %esi
js 0x4db5
cmpl %esi, 0xb0(%rdi)
jle 0x4db5
movslq %edx, %rax
movq 0xe8(%rdi), %rcx
mulsd (%rcx,%rax,8), %xmm1
divsd 0x48(%rdi), %xmm1
subsd %xmm1, %xmm0
retq
pushq %rax
leaq 0x2426(%rip), %rdi      # 0x71e3
leaq 0x2434(%rip), %rsi      # 0x71f8
leaq 0x248d(%rip), %rcx      # 0x7258
pushq $0x7a
popq %rdx
callq 0x20f0
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4dde(%rip), %rbx      # 0xaff0
movq %rbx, %rdi
callq 0x2180
leaq 0x1107(%rip), %rsi      # 0x7328
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
movq %r14, %rsi
callq 0x2180
leaq 0x10f5(%rip), %rsi      # 0x7330
movq %rax, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
movq %rax, %rdi
callq 0x20c0
leaq 0x112c(%rip), %rsi      # 0x7386
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
leaq 0x1158(%rip), %rsi      # 0x73c9
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
leaq 0x118c(%rip), %rsi      # 0x7414
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
leaq 0x11c2(%rip), %rsi      # 0x7461
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
leaq 0x1202(%rip), %rsi      # 0x74b8
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
leaq 0x1216(%rip), %rsi      # 0x74e3
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
leaq 0x1250(%rip), %rsi      # 0x7534
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
leaq 0x1283(%rip), %rsi      # 0x757e
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
leaq 0x12c6(%rip), %rsi      # 0x75d8
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
leaq 0x1308(%rip), %rsi      # 0x7631
movq %rbx, %rdi
callq 0x2180
movq %rax, %rdi
callq 0x20c0
xorl %edi, %edi
callq 0x21e0
// File: /workspace/github_cpp_makefile_star2_O2/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 0x6460
movl %edi, %ebp
pushq $0x1
popq %r14
movq 0x4e5f(%rip), %r12      # 0xb1c0
leaq 0xf8c(%rip), %r15       # 0x72f4
cmpl %ebp, %r14d
jge 0x6439
movslq %r14d, %rax
movq (%rbx,%rax,8), %rcx
cmpb $0x2d, (%rcx)
jne 0x63ab
movzbl 0x1(%rcx), %ecx
addl $-0x6b, %ecx
cmpl $0xc, %ecx
ja 0x6451
movslq (%r15,%rcx,4), %rcx
addq %r15, %rcx
jmpq *%rcx
incl %r14d
movq 0x8(%rbx,%rax,8), %rdi
callq 0x2280
movl %eax, 0x4e03(%rip)      # 0xb1ac
jmp 0x63be
testq %r12, %r12
jne 0x6442
movq %rcx, 0x4e05(%rip)      # 0xb1c0
movq %rcx, %r12
incl %r14d
jmp 0x6368
incl %r14d
movq 0x8(%rbx,%rax,8), %rdi
callq 0x21f0
movsd %xmm0, 0x4dc8(%rip)     # 0xb1a0
jmp 0x63be
incl %r14d
movq 0x8(%rbx,%rax,8), %rdi
callq 0x2280
movl %eax, 0x4dbb(%rip)      # 0xb1a8
jmp 0x63be
movb $0x1, 0x4dee(%rip)      # 0xb1e4
jmp 0x63be
movb $0x1, 0x4de6(%rip)      # 0xb1e5
incl %r14d
movq 0x8(%rbx,%rax,8), %rax
movq %rax, 0x4dc2(%rip)      # 0xb1d0
jmp 0x63be
incl %r14d
movq 0x8(%rbx,%rax,8), %rax
movq %rax, 0x4db9(%rip)      # 0xb1d8
jmp 0x63be
andl $0x0, 0x4d70(%rip)      # 0xb198
incl %r14d
movq 0x8(%rbx,%rax,8), %rax
movq %rax, 0x4d91(%rip)      # 0xb1c8
jmp 0x63be
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq (%rbx), %rdi
leaq 0x1227(%rip), %rsi      # 0x7673
callq 0x6204
movq (%rbx), %rdi
leaq 0x1208(%rip), %rsi      # 0x7663
callq 0x6204
movq (%rbx), %rdi
leaq 0x11e3(%rip), %rsi      # 0x764d
callq 0x6204
// File: /workspace/github_cpp_makefile_star2_O2/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 0x1040
movq 0x2c54(%rip), %rbx      # 0x3fd8
leaq 0xc87(%rip), %rsi       # 0x2012
movq %rbx, %rdi
callq 0x10f0
leaq 0x20(%r14), %rsi
movq %rax, %rdi
callq 0x10c0
leaq 0xc6e(%rip), %rsi       # 0x2014
movq %rax, %rdi
callq 0x10f0
movq %rax, %rdi
movq %r14, %rsi
callq 0x10c0
leaq 0xc57(%rip), %rsi       # 0x2017
movq %rax, %rdi
callq 0x10f0
leaq 0xc4c(%rip), %rsi       # 0x201b
movq %rbx, %rdi
callq 0x10f0
xorl %ebp, %ebp
pushq $0x14
popq %r15
leaq 0xc39(%rip), %r14       # 0x201d
callq 0x1040
cltd
idivl %r15d
addl $0x2, %edx
cmpl %edx, %ebp
jge 0x1403
movq %rbx, %rdi
movq %r14, %rsi
callq 0x10f0
incl %ebp
jmp 0x13e4
movq 0x2bce(%rip), %rdi      # 0x3fd8
leaq 0xc0e(%rip), %rsi       # 0x201f
callq 0x10f0
movq %rax, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x1070
// File: /workspace/github_cpp_makefile_star2_O2/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, %r14d
movq %rdi, %r15
leaq 0x20(%rdi), %rax
movq %rax, 0x10(%rdi)
andq $0x0, 0x18(%rdi)
addq $0x10, %rdi
movb $0x0, 0x20(%r15)
movl %edx, 0x8(%r15)
movq %rdi, 0x8(%rsp)
movq %rsi, 0x20(%rsp)
callq 0x1080
movslq %r14d, %rbx
movq %rbx, %r12
shlq $0x6, %r12
leaq 0x8(%r12), %rax
testl %r14d, %r14d
pushq $-0x1
popq %rdi
cmovnsq %rax, %rdi
movq %rdi, 0x18(%rsp)
callq 0x1030
movq %rbx, (%rax)
movq %rax, 0x10(%rsp)
leaq 0x8(%rax), %r13
testl %r14d, %r14d
je 0x159a
negq %r12
xorl %ebp, %ebp
movq %r13, %rbx
movq %rbx, %rdi
callq 0x1326
addq $-0x40, %rbp
addq $0x40, %rbx
cmpq %rbp, %r12
jne 0x1585
xorl %r12d, %r12d
testl %r14d, %r14d
cmovlel %r12d, %r14d
movq %r13, (%r15)
shlq $0x6, %r14
leaq 0x48(%rsp), %r13
leaq 0x28(%rsp), %rbp
cmpq %r12, %r14
je 0x1607
movq (%r15), %rbx
movq %r13, %rdi
movq 0x20(%rsp), %rsi
callq 0x1120
addq %r12, %rbx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x1428
movq %r13, %rdi
callq 0x1060
movq (%r15), %rbx
movq %rbp, %rdi
callq 0x167a
addq %r12, %rbx
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x142e
movq %rbp, %rdi
callq 0x1060
addq $0x40, %r12
jmp 0x15b5
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x1665
movq %rax, %r14
testq %rbp, %rbp
je 0x163b
negq %rbp
movq 0x10(%rsp), %rbx
addq $-0x38, %rbx
leaq (%rbx,%rbp), %rdi
callq 0x197e
addq $-0x40, %rbp
jne 0x162c
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x1160
jmp 0x1668
movq %rax, %r14
leaq 0x48(%rsp), %rdi
jmp 0x165e
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x1060
jmp 0x1668
movq %rax, %r14
movq 0x8(%rsp), %rdi
callq 0x1060
movq %r14, %rdi
callq 0x1140
// File: /workspace/github_cpp_makefile_star2_O2/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 %rbx
subq $0x50, %rsp
xorl %edi, %edi
callq 0x10d0
movl %eax, %edi
callq 0x10e0
pushq $0x30
popq %rdi
callq 0x1100
movq %rax, %rbx
leaq 0x6de(%rip), %rsi       # 0x209b
leaq 0x30(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1438
leaq 0x30(%rsp), %rsi
pushq $0x5
popq %rdx
movq %rbx, %rdi
callq 0x150c
leaq 0x30(%rsp), %rdi
callq 0x1060
pushq $0x30
popq %rdi
callq 0x1100
movq %rax, %r14
leaq 0x6a8(%rip), %rsi       # 0x20a0
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x1438
leaq 0x10(%rsp), %rsi
pushq $0xa
popq %rdx
movq %r14, %rdi
callq 0x150c
leaq 0x10(%rsp), %rdi
callq 0x1060
movq 0x25b0(%rip), %r15      # 0x3fd8
leaq 0x676(%rip), %rsi       # 0x20a5
movq %r15, %rdi
callq 0x10f0
movq %rax, %rdi
callq 0x1070
movq %rbx, %rdi
callq 0x18b4
leaq 0x662(%rip), %rsi       # 0x20b0
movq %r15, %rdi
callq 0x10f0
movq %rax, %rdi
callq 0x1070
movq %r14, %rdi
callq 0x18b4
movq %r14, %rdi
callq 0x184e
pushq $0x30
popq %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x1110
movq %rbx, %rdi
callq 0x184e
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1110
xorl %eax, %eax
addq $0x50, %rsp
popq %rbx
popq %r14
popq %r15
retq
movq %rax, %r15
leaq 0x10(%rsp), %rdi
callq 0x1060
jmp 0x1ac5
movq %rax, %r15
jmp 0x1ac5
movq %rax, %r15
leaq 0x30(%rsp), %rdi
callq 0x1060
jmp 0x1ac2
movq %rax, %r15
movq %rbx, %r14
pushq $0x30
popq %rsi
movq %r14, %rdi
callq 0x1110
movq %r15, %rdi
callq 0x1140
// File: /workspace/github_cpp_makefile_star2_O2/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
leaq 0x8(%rsp), %rax
movw %si, (%rax)
movl %edx, 0x4(%rax)
addq $0x38, %rdi
movq %rax, %rsi
callq 0x2c5c
movq 0x50(%rbx), %rax
movq 0x58(%rbx), %rcx
cmpq %rcx, %rax
je 0x2448
subq %rax, %rcx
shrq $0x3, %rcx
xorl %edx, %edx
testl %ecx, %ecx
cmovlel %edx, %ecx
cmpq %rdx, %rcx
je 0x2448
incl 0x4(%rax,%rdx,8)
incq %rdx
jmp 0x243a
movq 0x8(%rbx), %rax
movq 0x10(%rbx), %rcx
cmpq %rcx, %rax
je 0x2470
subq %rax, %rcx
shrq $0x2, %rcx
xorl %edx, %edx
testl %ecx, %ecx
cmovlel %edx, %ecx
cmpq %rdx, %rcx
je 0x2470
incl (%rax,%rdx,4)
incq %rdx
jmp 0x2463
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x80, %rsp
movq %rsi, %r15
movq %rdi, %r14
movq 0x68(%rdi), %r12
leaq 0x60(%rsp), %rbx
movq %rbx, %rdi
callq 0x2200
movq %r12, %rdi
movq %rbx, %rsi
callq 0x49c8
movl %eax, %ebp
leaq 0x60(%rsp), %rdi
callq 0x20c0
movq 0x68(%r14), %r12
testb %bpl, %bpl
je 0x253a
movzbl %bpl, %eax
cmpl $0x1, %eax
jne 0x2569
leaq 0x20(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2200
movq %r12, %rdi
movq %rbx, %rsi
callq 0x4aac
pushq $0x2
popq %rsi
movq %r14, %rdi
movl %eax, %edx
callq 0x2400
leaq 0x20(%rsp), %rdi
jmp 0x2592
leaq 0x40(%rsp), %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2200
movq %r12, %rdi
movq %rbx, %rsi
callq 0x4aac
pushq $0x1
popq %rsi
movq %r14, %rdi
movl %eax, %edx
callq 0x2400
leaq 0x40(%rsp), %rdi
jmp 0x2592
movq %rsp, %rbx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x2200
movq %r12, %rdi
movq %rbx, %rsi
callq 0x4aac
pushq $0x3
popq %rsi
movq %r14, %rdi
movl %eax, %edx
callq 0x2400
movq %rsp, %rdi
callq 0x20c0
movl %ebp, %eax
addq $0x80, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x25af
jmp 0x25af
jmp 0x25af
movq %rax, %r14
movq %rbx, %rdi
callq 0x20c0
movq %r14, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O2/protonpopsicle[P]lang/src/compiler/ByteCoder.cpp
// Function: ByteCoder::assignVar(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char)
char ByteCoder::assignVar(std::string id, char rhs) {
    char type = zoneMgr->getVarType(id);
    if (type == rhs) {
        switch (type) {
            case BOOL:
                addOp(OP_ASSIGN_BOOL, zoneMgr->getVarIndex(id));
                return type;
            case INT:
                addOp(OP_ASSIGN_INT, zoneMgr->getVarIndex(id));
                return type;
            case STRING:
                addOp(OP_ASSIGN_STRING, zoneMgr->getVarIndex(id));
                return type;
        }
    }
    throw Error("type mismatch in variable assignment");
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movl %edx, %ebx
movq %rsi, %r12
movq %rdi, %r14
movq 0x68(%rdi), %r15
leaq 0x28(%rsp), %r13
movq %r13, %rdi
callq 0x2200
movq %r15, %rdi
movq %r13, %rsi
callq 0x49c8
movl %eax, %ebp
leaq 0x28(%rsp), %rdi
callq 0x20c0
cmpb %bl, %bpl
jne 0x26c8
movsbl %bl, %eax
testl %eax, %eax
je 0x267d
cmpl $0x1, %eax
je 0x264f
cmpl $0x2, %eax
jne 0x26c8
movq 0x68(%r14), %r13
leaq 0x48(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x2200
movq %r13, %rdi
movq %r15, %rsi
callq 0x4aac
pushq $0x6
popq %rsi
movq %r14, %rdi
movl %eax, %edx
callq 0x2400
jmp 0x26ac
movq 0x68(%r14), %r13
leaq 0x68(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x2200
movq %r13, %rdi
movq %r15, %rsi
callq 0x4aac
pushq $0x5
popq %rsi
movq %r14, %rdi
movl %eax, %edx
callq 0x2400
jmp 0x26ac
movq 0x68(%r14), %r13
leaq 0x88(%rsp), %r15
movq %r15, %rdi
movq %r12, %rsi
callq 0x2200
movq %r13, %rdi
movq %r15, %rsi
callq 0x4aac
pushq $0x4
popq %rsi
movq %r14, %rdi
movl %eax, %edx
callq 0x2400
movq %r15, %rdi
callq 0x20c0
movl %ebx, %eax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x20d0
movq %rax, %rbx
leaq 0x3946(%rip), %rsi      # 0x6020
leaq 0x8(%rsp), %rdi
leaq 0x7(%rsp), %rdx
callq 0x2ca6
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x33fc
xorl %ebp, %ebp
leaq 0x76ae(%rip), %rsi      # 0x9db0
leaq 0x5d9(%rip), %rdx       # 0x2ce2
movq %rbx, %rdi
callq 0x2280
movq %rax, %r14
leaq 0x48(%rsp), %rdi
jmp 0x275b
movq %rax, %r14
leaq 0x88(%rsp), %rdi
jmp 0x275b
movq %rax, %r14
leaq 0x68(%rsp), %rdi
jmp 0x275b
movq %rax, %r14
leaq 0x8(%rsp), %rdi
callq 0x20c0
testb %bpl, %bpl
jne 0x2749
jmp 0x2760
movq %rax, %r14
movq %rbx, %rdi
callq 0x2110
jmp 0x2760
movq %rax, %r14
leaq 0x28(%rsp), %rdi
callq 0x20c0
movq %r14, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x30, %rsp
cmpb $0x1, %sil
jne 0x279b
movq %rdi, %rbx
pushq $-0x1
popq %rdx
xorl %esi, %esi
callq 0x2400
pushq $0x9
popq %rsi
movq %rbx, %rdi
xorl %edx, %edx
callq 0x2400
movb $0x1, %al
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x20d0
movq %rax, %rbx
leaq 0x3898(%rip), %rsi      # 0x6045
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x2ca6
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x33fc
xorl %ebp, %ebp
leaq 0x75db(%rip), %rsi      # 0x9db0
leaq 0x506(%rip), %rdx       # 0x2ce2
movq %rbx, %rdi
callq 0x2280
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x20c0
testb %bpl, %bpl
jne 0x27fb
jmp 0x2803
movq %rax, %r14
movq %rbx, %rdi
callq 0x2110
movq %r14, %rdi
callq 0x2290
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x30, %rsp
movl %edx, %eax
xorb $0x1, %al
movl %ecx, %r8d
xorb $0x1, %r8b
movl %eax, %r9d
orb %r8b, %r9b
jne 0x284c
addb $-0x2a, %sil
movb $0x1, %bl
cmpb $0x6, %sil
jae 0x2881
movzbl %sil, %eax
pushq $0x2b
popq %rcx
btl %eax, %ecx
jae 0x2881
leaq 0x37ce(%rip), %rcx      # 0x6014
movzwl (%rcx,%rax,2), %esi
jmp 0x2877
cmpb $0x2b, %sil
jne 0x288c
xorb $0x2, %dl
xorb $0x2, %cl
movb $0x2, %bl
movw $0xb, %si
movl %edx, %r9d
orb %cl, %r9b
je 0x2877
movw $0xc, %si
orb %r8b, %dl
je 0x2877
movw $0xd, %si
orb %cl, %al
jne 0x2881
movswl %si, %esi
xorl %edx, %edx
callq 0x2400
movl %ebx, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x20d0
movq %rax, %rbx
leaq 0x37c9(%rip), %rsi      # 0x6067
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x2ca6
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x33fc
xorl %ebp, %ebp
leaq 0x74ea(%rip), %rsi      # 0x9db0
leaq 0x415(%rip), %rdx       # 0x2ce2
movq %rbx, %rdi
callq 0x2280
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x20c0
testb %bpl, %bpl
jne 0x28ec
jmp 0x28f4
movq %rax, %r14
movq %rbx, %rdi
callq 0x2110
movq %r14, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x30, %rsp
movl %edx, %eax
xorb $0x1, %al
movl %ecx, %r8d
xorb $0x1, %r8b
orb %al, %r8b
jne 0x2938
movswl %si, %eax
leal -0x12c(%rax), %ecx
cmpl $0x3, %ecx
ja 0x2953
leaq 0x36db(%rip), %rax      # 0x6004
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movw $0x16, %ax
jmp 0x297f
orb %dl, %cl
jne 0x2994
movswl %si, %eax
cmpl $0x130, %eax            # imm = 0x130
je 0x2963
cmpl $0x131, %eax            # imm = 0x131
jne 0x2989
movw $0x1b, %ax
jmp 0x297f
cmpl $0x3c, %eax
je 0x2969
cmpl $0x3e, %eax
jne 0x2989
movw $0x15, %ax
jmp 0x297f
movw $0x1a, %ax
jmp 0x297f
movw $0x14, %ax
jmp 0x297f
movw $0x18, %ax
jmp 0x297f
movw $0x19, %ax
jmp 0x297f
movw $0x17, %ax
movzwl %ax, %esi
xorl %edx, %edx
callq 0x2400
xorl %eax, %eax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
retq
pushq $0x20
popq %rdi
callq 0x20d0
movq %rax, %rbx
leaq 0x36e8(%rip), %rsi      # 0x608e
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x2ca6
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x33fc
xorl %ebp, %ebp
leaq 0x73e2(%rip), %rsi      # 0x9db0
leaq 0x30d(%rip), %rdx       # 0x2ce2
movq %rbx, %rdi
callq 0x2280
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x20c0
testb %bpl, %bpl
jne 0x29f4
jmp 0x29fc
movq %rax, %r14
movq %rbx, %rdi
callq 0x2110
movq %r14, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
subq $0x30, %rsp
movw $0xe, %ax
cmpl $0x1, %esi
je 0x2a1e
cmpl $0x2, %esi
jne 0x2a30
movw $0xf, %ax
movzwl %ax, %esi
xorl %edx, %edx
addq $0x30, %rsp
popq %rbx
popq %r14
popq %rbp
jmp 0x2400
pushq $0x20
popq %rdi
callq 0x20d0
movq %rax, %rbx
leaq 0x3670(%rip), %rsi      # 0x60b2
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rdx
callq 0x2ca6
movb $0x1, %bpl
leaq 0x10(%rsp), %rsi
movq %rbx, %rdi
callq 0x33fc
xorl %ebp, %ebp
leaq 0x7346(%rip), %rsi      # 0x9db0
leaq 0x271(%rip), %rdx       # 0x2ce2
movq %rbx, %rdi
callq 0x2280
movq %rax, %r14
leaq 0x10(%rsp), %rdi
callq 0x20c0
testb %bpl, %bpl
jne 0x2a90
jmp 0x2a98
movq %rax, %r14
movq %rbx, %rdi
callq 0x2110
movq %r14, %rdi
callq 0x2290
// File: /workspace/github_cpp_makefile_star2_O2/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)
pushq $0x11
popq %rsi
callq 0x2400
movl (%rbx), %eax
leaq 0x8(%rsp), %rsi
movl %eax, (%rsi)
andl $0x0, 0x4(%rsi)
addq $0x50, %rbx
movq %rbx, %rdi
callq 0x2ce8
addq $0x10, %rsp
popq %rbx
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x357f(%rip), %r15      # 0x60de
xorl %r12d, %r12d
movq %rsi, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x2210
movq 0x68(%r14), %rax
movl 0x54(%rax), %edx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x2210
movq 0x68(%r14), %rax
movl 0x58(%rax), %edx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x2210
movq 0x28(%r14), %rdx
subq 0x20(%r14), %rdx
sarq $0x5, %rdx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x2210
movq 0x40(%r14), %rdx
subq 0x38(%r14), %rdx
sarq $0x3, %rdx
leaq 0x3510(%rip), %rsi      # 0x60d3
movq %rbx, %rdi
xorl %eax, %eax
callq 0x2210
movq 0x28(%r14), %r13
subq 0x20(%r14), %r13
shrq $0x5, %r13
testl %r13d, %r13d
cmovlel %r12d, %r13d
shlq $0x5, %r13
leaq 0x34ec(%rip), %r15      # 0x60d7
xorl %r12d, %r12d
cmpq %r12, %r13
je 0x2c0e
movq 0x20(%r14), %rax
movq (%rax,%r12), %rdx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x2210
addq $0x20, %r12
jmp 0x2bee
movq 0x40(%r14), %r12
subq 0x38(%r14), %r12
shrq $0x3, %r12
xorl %eax, %eax
testl %r12d, %r12d
cmovlel %eax, %r12d
leaq 0x34b1(%rip), %r15      # 0x60db
xorl %r13d, %r13d
cmpq %r13, %r12
je 0x2c52
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 0x2210
incq %r13
jmp 0x2c2d
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_cpp_makefile_star2_O2/protonpopsicle[P]lang/src/compiler/Error.cpp
// Function: Error::tagToStr[abi:cxx11](short)
std::string Error::tagToStr(short tag) {
    switch (tag) {
        case 32: 
            return "space";
        case 255: 
            return "program end";
        case NUM: 
            return "numeric literal";
        case QUOTE: 
            return "string literal";
        case ID: 
            return "identifier";
        case BASIC: 
            return "basic type";
        case TRUE: 
            return "true keyword";
        case FALSE: 
            return "false keyword";
        case PRINT: 
            return "print statement";
        case IF: 
            return "if statement";
        case WHILE: 
            return "while statement";
        case LE: 
            return "relational expression";
        case GE: 
            return "relational expression";
        case EQ: 
            return "relational expression";
        case NE: 
            return "relational expression";
        case AND: 
            return "relational expression";
        case OR: 
            return "relational expression";
        default: 
            // returns a string formed by 1 repetition of (char)tag
            return std::string(1, (unsigned char)tag);
    }
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
leal -0xff(%rdx), %eax
cmpl $0x9, %eax
ja 0x3572
leaq 0x2bd0(%rip), %rcx      # 0x6130
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x2c17(%rip), %rsi      # 0x6187
jmp 0x3594
leal -0x12c(%rdx), %eax
cmpl $0x5, %eax
ja 0x35aa
leaq 0x2bd4(%rip), %rcx      # 0x6158
movslq (%rcx,%rax,4), %rax
addq %rcx, %rax
jmpq *%rax
leaq 0x2c6c(%rip), %rsi      # 0x6200
leaq 0xf(%rsp), %rdx
movq %rbx, %rdi
callq 0x2ca6
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
retq
cmpl $0x20, %edx
jne 0x35d3
leaq 0x2bcb(%rip), %rsi      # 0x6181
jmp 0x3594
leaq 0x2bfe(%rip), %rsi      # 0x61bd
jmp 0x3594
leaq 0x2c28(%rip), %rsi      # 0x61f0
jmp 0x3594
leaq 0x2bd2(%rip), %rsi      # 0x61a3
jmp 0x3594
leaq 0x10(%rbx), %rax
movq %rax, (%rbx)
movsbl %dl, %edx
pushq $0x1
popq %rsi
movq %rbx, %rdi
callq 0x21b0
jmp 0x35a1
leaq 0x2bc1(%rip), %rsi      # 0x61b2
jmp 0x3594
leaq 0x2ac9(%rip), %rsi      # 0x60c3
jmp 0x3594
leaq 0x2b90(%rip), %rsi      # 0x6193
jmp 0x3594
leaq 0x2bbc(%rip), %rsi      # 0x61c8
jmp 0x3594
leaq 0x2bc0(%rip), %rsi      # 0x61d5
jmp 0x3594
leaq 0x2bc2(%rip), %rsi      # 0x61e3
jmp 0x3594
// File: /workspace/github_cpp_makefile_star2_O2/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
andl $0x0, 0x8(%rdi)
andq $0x0, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
andq $0x0, 0x28(%rdi)
movq %rsi, 0x30(%rdi)
movb $0x20, 0x38(%rdi)
movl $0x1, 0x3c(%rdi)
leaq 0x2b25(%rip), %rax      # 0x622f
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movl $0x103, 0x8(%rsi)       # imm = 0x103
callq 0x3c54
leaq 0x2af1(%rip), %rax      # 0x6216
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movl $0x103, 0x8(%rsi)       # imm = 0x103
movq %rbx, %rdi
callq 0x3c54
leaq 0x2ada(%rip), %rax      # 0x621d
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movl $0x103, 0x8(%rsi)       # imm = 0x103
movq %rbx, %rdi
callq 0x3c54
leaq 0x2ac1(%rip), %rax      # 0x6222
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movl $0x104, 0x8(%rsi)       # imm = 0x104
movq %rbx, %rdi
callq 0x3c54
leaq 0x2aa8(%rip), %rax      # 0x6227
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movl $0x105, 0x8(%rsi)       # imm = 0x105
movq %rbx, %rdi
callq 0x3c54
leaq 0x2a90(%rip), %rax      # 0x622d
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movl $0x106, 0x8(%rsi)       # imm = 0x106
movq %rbx, %rdi
callq 0x3c54
leaq 0x2a78(%rip), %rax      # 0x6233
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movl $0x107, 0x8(%rsi)       # imm = 0x107
movq %rbx, %rdi
callq 0x3c54
leaq 0x2a5d(%rip), %rax      # 0x6236
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movl $0x108, 0x8(%rsi)       # imm = 0x108
movq %rbx, %rdi
callq 0x3c54
leaq 0x2a45(%rip), %rax      # 0x623c
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movl $0x109, 0x8(%rsi)       # imm = 0x109
movq %rbx, %rdi
callq 0x3c54
addq $0x18, %rsp
popq %rbx
popq %r14
retq
jmp 0x3826
jmp 0x3826
jmp 0x3826
jmp 0x3826
jmp 0x3826
jmp 0x3826
jmp 0x3826
jmp 0x3826
movq %rax, %r14
movq %rbx, %rdi
callq 0x3bf0
movq %r14, %rdi
callq 0x2290
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x383a
movzbl 0x38(%r14), %eax
cmpl %ebx, %eax
jne 0x3868
movb $0x20, 0x38(%r14)
cmpl %ebx, %eax
sete %al
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x4714
movq %r12, (%rbx)
movq %r15, 0x8(%rbx)
movq %r14, 0x10(%rbx)
movq %rbx, %rdi
callq 0x3f70
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
addq $0x20, %rbx
movq %rbx, %rdi
callq 0x20c0
movq %r14, %rdi
callq 0x2290
nop
// File: /workspace/github_cpp_makefile_star2_O2/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 0x3fc5
movq %r14, %rdi
popq %rbx
popq %r14
popq %rbp
jmp 0x3f70
pushq $0x20
popq %rdi
callq 0x20d0
movq %rax, %rbx
movswl 0x18(%r14), %edx
movswl %bp, %esi
movq %rax, %rdi
callq 0x3434
leaq 0x5dc9(%rip), %rsi      # 0x9db0
leaq -0x130c(%rip), %rdx     # 0x2ce2
movq %rbx, %rdi
callq 0x2280
movq %rax, %r14
movq %rbx, %rdi
callq 0x2110
movq %r14, %rdi
callq 0x2290
nop
// File: /workspace/github_cpp_makefile_star2_O2/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
pushq $0x7b
popq %rsi
callq 0x3faa
movq 0x8(%rbx), %rdi
callq 0x4824
movq 0x8(%rbx), %rdi
callq 0x480e
movq %rbx, %rdi
callq 0x404c
pushq $0x7d
popq %rsi
movq %rbx, %rdi
callq 0x3faa
movq 0x8(%rbx), %rdi
popq %rbx
jmp 0x482a
nop