LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_cpp_makefile_star2_O3/dm4[P]huffman-homework/decode.cc
// Function: alignBuf(char*)
void alignBuf(char buf[5]) {
    int index = 0;
    int num = 0;
    for (int i = 0; i < 4; i++) {
        if (buf[i]) {
            buf[index++] = buf[i];
            num++;
        }
    }
    for (int i = num; i < 4; i++) {
        buf[i] = 0;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
xorl %ecx, %ecx
xorl %eax, %eax
xorl %edx, %edx
movb (%rdi,%rcx), %sil
testb %sil, %sil
je 0x156a
movslq %edx, %r8
incl %edx
movb %sil, (%rdi,%r8)
incl %eax
incq %rcx
cmpq $0x4, %rcx
jne 0x1556
cmpl $0x3, %eax
jg 0x1590
movslq %eax, %rcx
addq %rcx, %rdi
movl $0x3, %edx
subl %eax, %edx
incq %rdx
xorl %esi, %esi
popq %rbp
jmp 0x10a0
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/riyadparvez[P]louvain-method/graph_binary.cpp
// Function: Graph::Graph(std::vector<std::vector<int, std::allocator<int>>, std::allocator<std::vector<int, std::allocator<int>>>>&)
Graph::Graph(vector<vector<int> >& c_nodes) {
  nb_nodes     = 0;
  nb_links     = 0;
  total_weight = 0;
  
  nodes.reserve(c_nodes.size());
  for (size_t i=0; i<c_nodes.size(); i++) {
    nodes.push_back(c_nodes[i]);
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r15
movq %rdi, %rbx
movl $0x0, (%rdi)
xorps %xmm0, %xmm0
movups %xmm0, 0x8(%rdi)
movups %xmm0, 0x18(%rdi)
movups %xmm0, 0x28(%rdi)
movups %xmm0, 0x38(%rdi)
movups %xmm0, 0x48(%rdi)
movups %xmm0, 0x58(%rdi)
movups %xmm0, 0x68(%rdi)
movq 0x8(%rsi), %rsi
subq (%r15), %rsi
leaq 0x30(%rdi), %r14
sarq $0x3, %rsi
movabsq $-0x5555555555555555, %r12 # imm = 0xAAAAAAAAAAAAAAAB
imulq %r12, %rsi
movq %r14, %rdi
callq 0x3274
movq (%r15), %rsi
cmpq %rsi, 0x8(%r15)
je 0x2a4e
xorl %r13d, %r13d
xorl %ebp, %ebp
addq %r13, %rsi
movq %r14, %rdi
callq 0x31f4
incq %rbp
movq (%r15), %rsi
movq 0x8(%r15), %rax
subq %rsi, %rax
sarq $0x3, %rax
imulq %r12, %rax
addq $0x18, %r13
cmpq %rax, %rbp
jb 0x2a25
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2a5f
movq %rax, %r15
movq 0x60(%rbx), %rdi
testq %rdi, %rdi
je 0x2a77
movq 0x70(%rbx), %rsi
subq %rdi, %rsi
callq 0x2200
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x2a8c
movq 0x58(%rbx), %rsi
subq %rdi, %rsi
callq 0x2200
movq %r14, %rdi
callq 0x3220
movq 0x18(%rbx), %rdi
testq %rdi, %rdi
je 0x2aa9
movq 0x28(%rbx), %rsi
subq %rdi, %rsi
callq 0x2200
movq %r15, %rdi
callq 0x2370
nop
// File: /workspace/github_cpp_makefile_star2_O3/riyadparvez[P]louvain-method/graph_binary.cpp
// Function: Graph::write_community(char const*)
void
Graph::write_community(const char *filename_w) {
  FILE* fOut = fopen(filename_w, "wt");
  for (size_t i=0; i<nodes.size(); i++) {
    for (size_t j=0; j<nodes[i].size(); j++) {
      fprintf(fOut, "%d ", nodes[i][j]);  
    }
    fprintf(fOut, "\n");  
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rax
movq %rdi, %rbx
leaq 0x54d8(%rip), %rsi      # 0x8074
movq %rax, %rdi
callq 0x2240
movq %rax, %r14
movq 0x30(%rbx), %rax
cmpq %rax, 0x38(%rbx)
je 0x2c37
leaq 0x54bb(%rip), %r15      # 0x8077
xorl %r13d, %r13d
leaq (,%r13,2), %rbp
addq %r13, %rbp
movq (%rax,%rbp,8), %rcx
cmpq %rcx, 0x8(%rax,%rbp,8)
je 0x2c05
xorl %r12d, %r12d
movl (%rcx,%r12,4), %edx
movq %r14, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x22a0
incq %r12
movq 0x30(%rbx), %rax
movq (%rax,%rbp,8), %rcx
movq 0x8(%rax,%rbp,8), %rax
subq %rcx, %rax
sarq $0x2, %rax
cmpq %rax, %r12
jb 0x2bd8
movl $0xa, %edi
movq %r14, %rsi
callq 0x2270
incq %r13
movq 0x30(%rbx), %rax
movq 0x38(%rbx), %rcx
subq %rax, %rcx
sarq $0x3, %rcx
movabsq $-0x5555555555555555, %rdx # imm = 0xAAAAAAAAAAAAAAAB
imulq %rdx, %rcx
cmpq %rcx, %r13
jb 0x2bbf
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_cpp_makefile_star2_O3/riyadparvez[P]louvain-method/graph_binary.cpp
// Function: Graph::display_reverse()
void
Graph::display_reverse() {
  for (unsigned int node=0 ; node<nb_nodes ; node++) {
    pair<vector<unsigned int>::iterator, vector<float>::iterator > p = neighbors(node);
    for (unsigned int i=0 ; i<nb_neighbors(node) ; i++) {
      if (node>*(p.first+i)) {
	if (weights.size()!=0)
	  cout << *(p.first+i) << " " << node << " " << *(p.second+i) << endl;
	else
	  cout << *(p.first+i) << " " << node << endl;
      }
    }   
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl (%rdi), %eax
testl %eax, %eax
je 0x2da1
movq %rdi, %rbx
xorl %r14d, %r14d
movq 0x60(%rbx), %rsi
testq %r14, %r14
je 0x2c99
movq 0x18(%rbx), %rcx
movq -0x8(%rcx,%r14,8), %rcx
leaq (,%rcx,4), %rdi
addq 0x48(%rbx), %rdi
cmpq %rsi, 0x68(%rbx)
movl $0x0, %edx
cmovneq %rcx, %rdx
leaq (%rsi,%rdx,4), %rsi
movq %rsi, (%rsp)
jmp 0x2ca1
movq %rsi, (%rsp)
movq 0x48(%rbx), %rdi
movl %eax, %ecx
cmpq %rcx, %r14
jae 0x2db0
leal -0x1(%r14), %ecx
movq %rcx, 0x10(%rsp)
xorl %ebp, %ebp
movq %rdi, 0x8(%rsp)
movq 0x18(%rbx), %rdx
testq %r14, %r14
je 0x2cd4
movq (%rdx,%r14,8), %rcx
movq 0x10(%rsp), %rsi
subq (%rdx,%rsi,8), %rcx
jmp 0x2cd6
movl (%rdx), %ecx
movl %ecx, %ecx
cmpq %rcx, %rbp
jae 0x2d93
movl (%rdi,%rbp,4), %esi
cmpq %rsi, %r14
jbe 0x2d83
movq 0x68(%rbx), %r12
movq 0x60(%rbx), %r15
movq 0x92d4(%rip), %rdi      # 0xbfd0
callq 0x2140
movq %rax, %r13
movl $0x1, %edx
movq %rax, %rdi
leaq 0x59e8(%rip), %rsi      # 0x86fb
callq 0x2230
movq %r13, %rdi
movq %r14, %rsi
callq 0x2140
movq %rax, %r13
cmpq %r15, %r12
je 0x2d56
movl $0x1, %edx
movq %r13, %rdi
leaq 0x59c1(%rip), %rsi      # 0x86fb
callq 0x2230
movq (%rsp), %rax
xorps %xmm0, %xmm0
cvtss2sd (%rax,%rbp,4), %xmm0
movq %r13, %rdi
callq 0x2300
movq %rax, %r13
movq (%r13), %rax
movq -0x18(%rax), %rdi
addq %r13, %rdi
movl $0xa, %esi
callq 0x21d0
movsbl %al, %esi
movq %r13, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2150
movq 0x8(%rsp), %rdi
incq %rbp
movl (%rbx), %eax
cmpq %rax, %r14
jb 0x2cbc
jmp 0x2db0
incq %r14
movl %eax, %ecx
cmpq %rcx, %r14
jb 0x2c64
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x52c4(%rip), %rdi      # 0x807b
leaq 0x52d6(%rip), %rsi      # 0x8094
leaq 0x533d(%rip), %rcx      # 0x8102
movl $0x5a, %edx
callq 0x2130
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x2220
movq %r15, %rdi
movq %r14, %rsi
movl $0x8, %edx
callq 0x2120
movq 0x8(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x28(%rsp,%rax)
jne 0x4512
leaq 0x8(%rsp), %r14
movq %rsp, %r15
leaq 0x4(%rsp), %r12
movq %r14, %rdi
movq %r15, %rsi
callq 0x2360
movq %rax, %rdi
movq %r12, %rsi
callq 0x2360
movq 0x8(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x5, 0x28(%rsp,%rax)
jne 0x44fe
movl (%rsp), %esi
movq 0xb8(%rbx), %rax
movslq (%rax,%rsi,4), %r13
movq %rbx, %rdi
callq 0x4554
movl (%rsp), %esi
movq (%rbx), %rax
movsd (%rax,%r13,8), %xmm0
movq %rbx, %rdi
movl %r13d, %edx
callq 0x5568
movl 0x30(%rbx), %eax
testq %rax, %rax
je 0x44ec
movq 0x18(%rbx), %rcx
movl 0x4(%rsp), %edx
xorl %r13d, %r13d
cmpl %edx, (%rcx,%r13,4)
je 0x44cc
incq %r13
cmpq %r13, %rax
jne 0x44bc
jmp 0x44ec
movq (%rbx), %rax
xorps %xmm0, %xmm0
cvtsd2ss (%rax,%rdx,8), %xmm0
movl (%rsp), %esi
cvtss2sd %xmm0, %xmm0
movq %rbx, %rdi
callq 0x571e
cmpl %r13d, 0x30(%rbx)
jne 0x44fe
movl (%rsp), %esi
movl 0x4(%rsp), %edx
xorps %xmm0, %xmm0
movq %rbx, %rdi
callq 0x571e
movq 0x8(%rsp), %rax
movq -0x18(%rax), %rax
testb $0x2, 0x28(%rsp,%rax)
je 0x4452
leaq 0x8(%rsp), %rdi
callq 0x2060
leaq 0x8(%rsp), %rdi
callq 0x2070
addq $0x210, %rsp            # imm = 0x210
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
jmp 0x453f
jmp 0x453f
jmp 0x453f
jmp 0x453f
movq %rax, %rbx
leaq 0x8(%rsp), %rdi
callq 0x2070
movq %rbx, %rdi
callq 0x2370
// File: /workspace/github_cpp_makefile_star2_O3/riyadparvez[P]louvain-method/community.cpp
// Function: Community::neigh_comm(unsigned int)
void
Community::neigh_comm(unsigned int node) {
  for (unsigned int i=0 ; i<neigh_last ; i++)
    neigh_weight[neigh_pos[i]]=-1;
  neigh_last=0;

  pair<vector<unsigned int>::iterator, vector<float>::iterator> p = g.neighbors(node);

  unsigned int deg = g.nb_neighbors(node);

  neigh_pos[0]=n2c[node];
  neigh_weight[neigh_pos[0]]=0;
  neigh_last=1;

  for (unsigned int i=0 ; i<deg ; i++) {
    unsigned int neigh        = *(p.first+i);
    unsigned int neigh_comm   = n2c[neigh];
    double neigh_w = (g.weights.size()==0)?1.:*(p.second+i);
    
    if (neigh!=node) {
      if (neigh_weight[neigh_comm]==-1) {
	    neigh_weight[neigh_comm]=0.;
	    neigh_pos[neigh_last++]=neigh_comm;
      }
      neigh_weight[neigh_comm]+=neigh_w;
    }
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl 0x30(%rdi), %eax
testq %rax, %rax
je 0x4588
movq (%rdi), %rcx
movq 0x18(%rdi), %rdx
xorl %r8d, %r8d
movabsq $-0x4010000000000000, %r9 # imm = 0xBFF0000000000000
movl (%rdx,%r8,4), %r10d
movq %r9, (%rcx,%r10,8)
incq %r8
cmpq %r8, %rax
jne 0x4578
movl $0x0, 0x30(%rdi)
cmpl %esi, 0x38(%rdi)
jbe 0x4693
testl %esi, %esi
je 0x45da
movq 0x50(%rdi), %r8
movq 0x98(%rdi), %rax
leal -0x1(%rsi), %ecx
movq (%r8,%rcx,8), %r9
leaq (,%r9,4), %rcx
addq 0x80(%rdi), %rcx
xorl %edx, %edx
cmpq %rax, 0xa0(%rdi)
cmovneq %r9, %rdx
leaq (%rax,%rdx,4), %rdx
movl %esi, %r10d
movq (%r8,%r10,8), %rbx
subq %r9, %rbx
jmp 0x45f4
movq 0x50(%rdi), %rdx
movq 0x80(%rdi), %rcx
movq 0x98(%rdi), %rax
movl (%rdx), %ebx
xorl %r10d, %r10d
movq %rax, %rdx
movq 0x18(%rdi), %r8
movq 0xb8(%rdi), %r9
movl (%r9,%r10,4), %r11d
movl %r11d, (%r8)
movq (%rdi), %r10
movq $0x0, (%r10,%r11,8)
movl $0x1, 0x30(%rdi)
testl %ebx, %ebx
je 0x468a
movq 0xa0(%rdi), %r11
movl %ebx, %ebx
xorl %r14d, %r14d
movsd 0x3b48(%rip), %xmm0     # 0x8178
movsd 0x3b48(%rip), %xmm1     # 0x8180
movaps %xmm0, %xmm2
cmpq %rax, %r11
je 0x4649
xorps %xmm2, %xmm2
cvtss2sd (%rdx,%r14,4), %xmm2
movl (%rcx,%r14,4), %r15d
cmpl %esi, %r15d
je 0x4682
movl (%r9,%r15,4), %r15d
movsd (%r10,%r15,8), %xmm3
ucomisd %xmm1, %xmm3
jne 0x4678
jp 0x4678
movl 0x30(%rdi), %r12d
leal 0x1(%r12), %ebp
movl %ebp, 0x30(%rdi)
movl %r15d, (%r8,%r12,4)
xorpd %xmm3, %xmm3
addsd %xmm3, %xmm2
movsd %xmm2, (%r10,%r15,8)
incq %r14
cmpq %r14, %rbx
jne 0x4638
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
leaq 0x39e1(%rip), %rdi      # 0x807b
leaq 0x39f3(%rip), %rsi      # 0x8094
leaq 0x39fd(%rip), %rcx      # 0x80a5
movl $0x84, %edx
callq 0x2130
// File: /workspace/github_cpp_makefile_star2_O3/riyadparvez[P]louvain-method/community.cpp
// Function: Community::modularity()
double
Community::modularity() {
  double q  = 0.;
  double m2 = (double)g.total_weight;

  for (int i=0 ; i<size ; i++) {
    if (tot[i]>0)
      q += (double)in[i]/m2 - ((double)tot[i]/m2)*((double)tot[i]/m2);
  }

  return q;
}

// Assembly:
movslq 0xb0(%rdi), %rax
testq %rax, %rax
jle 0x481c
movsd 0x48(%rdi), %xmm1
movq 0xd0(%rdi), %rcx
movq 0xe8(%rdi), %rdx
xorpd %xmm2, %xmm2
xorl %esi, %esi
xorpd %xmm0, %xmm0
movsd (%rdx,%rsi,8), %xmm3
ucomisd %xmm2, %xmm3
jbe 0x4813
movsd (%rcx,%rsi,8), %xmm4
divsd %xmm1, %xmm4
divsd %xmm1, %xmm3
mulsd %xmm3, %xmm3
subsd %xmm3, %xmm4
addsd %xmm4, %xmm0
incq %rsi
cmpq %rsi, %rax
jne 0x47ef
retq
xorps %xmm0, %xmm0
retq
// File: /workspace/github_cpp_makefile_star2_O3/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
movl $0xffffffff, (%rdx)     # imm = 0xFFFFFFFF
leaq 0x10(%rsp), %rdi
leaq 0xf(%rsp), %rcx
callq 0x58c8
cmpl $0x0, 0xb0(%rbx)
jle 0x49b5
movq 0xb8(%rbx), %rcx
movq 0x10(%rsp), %rdx
xorl %esi, %esi
movslq (%rcx,%rsi,4), %rax
incl (%rdx,%rax,4)
incq %rsi
movslq 0xb0(%rbx), %rax
cmpq %rax, %rsi
jl 0x486d
testl %eax, %eax
jle 0x49b5
xorl %ecx, %ecx
movq 0x10(%rsp), %rdx
xorl %esi, %esi
cmpl $-0x1, (%rdx,%rcx,4)
je 0x48a5
movl %esi, (%rdx,%rcx,4)
incl %esi
movl 0xb0(%rbx), %eax
incq %rcx
movslq %eax, %rdi
cmpq %rdi, %rcx
jl 0x4894
testl %eax, %eax
jle 0x49b5
xorl %edi, %edi
movl 0x38(%rbx), %ecx
cmpq %rcx, %rdi
jae 0x49db
movq 0x80(%rbx), %rsi
testq %rdi, %rdi
je 0x48ea
leal -0x1(%rdi), %ecx
movq 0x50(%rbx), %rdx
movq (%rdx,%rcx,8), %rcx
leaq (%rsi,%rcx,4), %rsi
movq (%rdx,%rdi,8), %rdx
subq %rcx, %rdx
jmp 0x48f1
movq 0x50(%rbx), %rcx
movq (%rcx), %rdx
testl %edx, %edx
jle 0x49a6
andl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
movq %rdx, 0x28(%rsp)
xorl %r15d, %r15d
movq %rsi, %r13
movslq (%rsi,%r15,4), %rbp
movq 0xb8(%rbx), %rax
movq %rdi, %r14
movslq (%rax,%rdi,4), %rax
movq 0x10(%rsp), %rcx
movl (%rcx,%rax,4), %esi
movq 0x76a5(%rip), %rdi      # 0xbfd0
callq 0x2350
movq %rax, %r12
movl $0x1, %edx
movq %rax, %rdi
leaq 0x3db9(%rip), %rsi      # 0x86fb
callq 0x2230
movq 0xb8(%rbx), %rax
movslq (%rax,%rbp,4), %rax
movq 0x10(%rsp), %rcx
movl (%rcx,%rax,4), %esi
movq %r12, %rdi
callq 0x2350
movq %rax, %r12
movq (%rax), %rax
movq -0x18(%rax), %rdi
addq %r12, %rdi
movl $0xa, %esi
callq 0x21d0
movsbl %al, %esi
movq %r12, %rdi
callq 0x2030
movq %rax, %rdi
callq 0x2150
incq %r15
cmpq %r15, 0x28(%rsp)
movq %r13, %rsi
movq %r14, %rdi
jne 0x4907
movl 0xb0(%rbx), %eax
incq %rdi
movslq %eax, %rcx
cmpq %rcx, %rdi
jl 0x48ba
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x49cc
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x2200
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x3699(%rip), %rdi      # 0x807b
leaq 0x36ab(%rip), %rsi      # 0x8094
leaq 0x36b5(%rip), %rcx      # 0x80a5
movl $0x84, %edx
callq 0x2130
movq %rax, %rbx
movq 0x10(%rsp), %rdi
testq %rdi, %rdi
je 0x4a14
movq 0x20(%rsp), %rsi
subq %rdi, %rsi
callq 0x2200
movq %rbx, %rdi
callq 0x2370
// File: /workspace/github_cpp_makefile_star2_O3/riyadparvez[P]louvain-method/community.cpp
// Function: Community::display_partition()
void
Community::display_partition() {
  vector<int> renumber(size, -1);
  for (int node=0 ; node<size ; node++) {
    renumber[n2c[node]]++;
  }

  int final=0;
  for (int i=0 ; i<size ; i++)
    if (renumber[i]!=-1)
      renumber[i]=final++;

  for (int i=0 ; i<size ; i++)
    cout << i << " " << renumber[n2c[i]] << endl;
}

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

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testl %esi, %esi
js 0x56df
cmpl %esi, 0xb0(%rdi)
jle 0x56df
cmpl %esi, 0x38(%rdi)
jbe 0x56fe
movq 0x98(%rdi), %rcx
movq 0xa0(%rdi), %r8
movl %esi, %eax
cmpq %rcx, %r8
je 0x55b5
testl %esi, %esi
je 0x55c8
leal -0x1(%rsi), %r9d
movq 0x50(%rdi), %r10
movq (%r10,%r9,8), %r11
leaq (%rcx,%r11,4), %r11
jmp 0x55d5
testl %esi, %esi
je 0x5606
movq 0x50(%rdi), %r10
movq (%r10,%rax,8), %r9
subq -0x8(%r10,%rax,8), %r9
jmp 0x560d
movl $0xffffffff, %r9d       # imm = 0xFFFFFFFF
movq 0x50(%rdi), %r10
movq %rcx, %r11
xorpd %xmm1, %xmm1
xorl %ebx, %ebx
testl %esi, %esi
je 0x55e9
movq (%r10,%rax,8), %r14
subq (%r10,%r9,8), %r14
jmp 0x55ec
movl (%r10), %r14d
movl %r14d, %r14d
cmpq %r14, %rbx
jae 0x5615
xorps %xmm2, %xmm2
cvtss2sd (%r11,%rbx,4), %xmm2
addsd %xmm2, %xmm1
incq %rbx
jmp 0x55db
movq 0x50(%rdi), %r9
movq (%r9), %r9
movl %r9d, %r9d
cvtsi2sd %r9, %xmm1
movslq %edx, %rdx
movq 0xe8(%rdi), %r9
movsd (%r9,%rdx,8), %xmm2
subsd %xmm1, %xmm2
movsd %xmm2, (%r9,%rdx,8)
movq 0x80(%rdi), %r9
testl %esi, %esi
je 0x5659
leal -0x1(%rsi), %r10d
xorl %ebx, %ebx
cmpq %rcx, %r8
movq 0x50(%rdi), %r11
movq (%r11,%r10,8), %r14
leaq (%r9,%r14,4), %r9
cmovneq %r14, %rbx
leaq (%rcx,%rbx,4), %rbx
jmp 0x5666
movl $0xffffffff, %r10d      # imm = 0xFFFFFFFF
movq 0x50(%rdi), %r11
movq %rcx, %rbx
xorl %r14d, %r14d
testl %esi, %esi
je 0x5677
movq (%r11,%rax,8), %r15
subq (%r11,%r10,8), %r15
jmp 0x567a
movl (%r11), %r15d
movl %r15d, %r15d
cmpq %r15, %r14
jae 0x56a0
leaq 0x1(%r14), %r15
cmpl %esi, (%r9,%r14,4)
movq %r15, %r14
jne 0x5669
cmpq %rcx, %r8
je 0x56a6
xorps %xmm1, %xmm1
cvtss2sd -0x4(%rbx,%r15,4), %xmm1
jmp 0x56ae
xorpd %xmm1, %xmm1
jmp 0x56ae
movsd 0x2aca(%rip), %xmm1     # 0x8178
addsd %xmm0, %xmm0
addsd %xmm1, %xmm0
movq 0xd0(%rdi), %rcx
movsd (%rcx,%rdx,8), %xmm1
subsd %xmm0, %xmm1
movsd %xmm1, (%rcx,%rdx,8)
movq 0xb8(%rdi), %rcx
movl $0xffffffff, (%rcx,%rax,4) # imm = 0xFFFFFFFF
popq %rbx
popq %r14
popq %r15
retq
leaq 0x2b31(%rip), %rdi      # 0x8217
leaq 0x2b3f(%rip), %rsi      # 0x822c
leaq 0x2b46(%rip), %rcx      # 0x823a
movl $0x68, %edx
callq 0x2130
leaq 0x2976(%rip), %rdi      # 0x807b
leaq 0x2988(%rip), %rsi      # 0x8094
leaq 0x2aaf(%rip), %rcx      # 0x81c2
movl $0x74, %edx
callq 0x2130
nop
// File: /workspace/github_cpp_makefile_star2_O3/riyadparvez[P]louvain-method/./community.h
// Function: Community::insert(int, int, double)
inline void
Community::insert(int node, int comm, double dnodecomm) {
  assert(node>=0 && node<size);

  tot[comm] += g.weighted_degree(node);
  in[comm]  += 2*dnodecomm + g.nb_selfloops(node);
  n2c[node]=comm;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testl %esi, %esi
js 0x5889
cmpl %esi, 0xb0(%rdi)
jle 0x5889
cmpl %esi, 0x38(%rdi)
jbe 0x58a8
movq 0x98(%rdi), %rcx
movq 0xa0(%rdi), %r8
movl %esi, %eax
cmpq %rcx, %r8
je 0x576b
testl %esi, %esi
je 0x577e
leal -0x1(%rsi), %r9d
movq 0x50(%rdi), %r10
movq (%r10,%r9,8), %r11
leaq (%rcx,%r11,4), %r11
jmp 0x578b
testl %esi, %esi
je 0x57bc
movq 0x50(%rdi), %r10
movq (%r10,%rax,8), %r9
subq -0x8(%r10,%rax,8), %r9
jmp 0x57c3
movl $0xffffffff, %r9d       # imm = 0xFFFFFFFF
movq 0x50(%rdi), %r10
movq %rcx, %r11
xorpd %xmm1, %xmm1
xorl %ebx, %ebx
testl %esi, %esi
je 0x579f
movq (%r10,%rax,8), %r14
subq (%r10,%r9,8), %r14
jmp 0x57a2
movl (%r10), %r14d
movl %r14d, %r14d
cmpq %r14, %rbx
jae 0x57cb
xorps %xmm2, %xmm2
cvtss2sd (%r11,%rbx,4), %xmm2
addsd %xmm2, %xmm1
incq %rbx
jmp 0x5791
movq 0x50(%rdi), %r9
movq (%r9), %r9
movl %r9d, %r9d
cvtsi2sd %r9, %xmm1
movslq %edx, %rdx
movq 0xe8(%rdi), %r9
addsd (%r9,%rdx,8), %xmm1
movsd %xmm1, (%r9,%rdx,8)
movq 0x80(%rdi), %r9
testl %esi, %esi
je 0x580b
leal -0x1(%rsi), %r10d
xorl %ebx, %ebx
cmpq %rcx, %r8
movq 0x50(%rdi), %r11
movq (%r11,%r10,8), %r14
leaq (%r9,%r14,4), %r9
cmovneq %r14, %rbx
leaq (%rcx,%rbx,4), %rbx
jmp 0x5818
movl $0xffffffff, %r10d      # imm = 0xFFFFFFFF
movq 0x50(%rdi), %r11
movq %rcx, %rbx
xorl %r14d, %r14d
testl %esi, %esi
je 0x5829
movq (%r11,%rax,8), %r15
subq (%r11,%r10,8), %r15
jmp 0x582c
movl (%r11), %r15d
movl %r15d, %r15d
cmpq %r15, %r14
jae 0x5852
leaq 0x1(%r14), %r15
cmpl %esi, (%r9,%r14,4)
movq %r15, %r14
jne 0x581b
cmpq %rcx, %r8
je 0x5858
xorps %xmm1, %xmm1
cvtss2sd -0x4(%rbx,%r15,4), %xmm1
jmp 0x5860
xorpd %xmm1, %xmm1
jmp 0x5860
movsd 0x2918(%rip), %xmm1     # 0x8178
addsd %xmm0, %xmm0
addsd %xmm1, %xmm0
movq 0xd0(%rdi), %rcx
addsd (%rcx,%rdx,8), %xmm0
movsd %xmm0, (%rcx,%rdx,8)
movq 0xb8(%rdi), %rcx
movl %edx, (%rcx,%rax,4)
popq %rbx
popq %r14
popq %r15
retq
leaq 0x2987(%rip), %rdi      # 0x8217
leaq 0x2995(%rip), %rsi      # 0x822c
leaq 0x29c5(%rip), %rcx      # 0x8263
movl $0x71, %edx
callq 0x2130
leaq 0x27cc(%rip), %rdi      # 0x807b
leaq 0x27de(%rip), %rsi      # 0x8094
leaq 0x2905(%rip), %rcx      # 0x81c2
movl $0x74, %edx
callq 0x2130
nop
// File: /workspace/github_cpp_makefile_star2_O3/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 0x512a(%rip), %rbx      # 0xbff0
movq %rbx, %rdi
callq 0x21e0
leaq 0x1487(%rip), %rsi      # 0x835c
movq %rbx, %rdi
callq 0x21e0
movq %rax, %rdi
movq %r14, %rsi
callq 0x21e0
leaq 0x1475(%rip), %rsi      # 0x8364
movq %rax, %rdi
callq 0x21e0
movq %rax, %rdi
callq 0x20f0
movq %rax, %rdi
callq 0x20f0
leaq 0x14ac(%rip), %rsi      # 0x83ba
movq %rbx, %rdi
callq 0x21e0
movq %rax, %rdi
callq 0x20f0
leaq 0x14d8(%rip), %rsi      # 0x83fd
movq %rbx, %rdi
callq 0x21e0
movq %rax, %rdi
callq 0x20f0
leaq 0x150c(%rip), %rsi      # 0x8448
movq %rbx, %rdi
callq 0x21e0
movq %rax, %rdi
callq 0x20f0
leaq 0x1542(%rip), %rsi      # 0x8495
movq %rbx, %rdi
callq 0x21e0
movq %rax, %rdi
callq 0x20f0
leaq 0x1582(%rip), %rsi      # 0x84ec
movq %rbx, %rdi
callq 0x21e0
movq %rax, %rdi
callq 0x20f0
leaq 0x1596(%rip), %rsi      # 0x8517
movq %rbx, %rdi
callq 0x21e0
movq %rax, %rdi
callq 0x20f0
leaq 0x15d0(%rip), %rsi      # 0x8568
movq %rbx, %rdi
callq 0x21e0
movq %rax, %rdi
callq 0x20f0
leaq 0x1603(%rip), %rsi      # 0x85b2
movq %rbx, %rdi
callq 0x21e0
movq %rax, %rdi
callq 0x20f0
leaq 0x1646(%rip), %rsi      # 0x860c
movq %rbx, %rdi
callq 0x21e0
movq %rax, %rdi
callq 0x20f0
leaq 0x1688(%rip), %rsi      # 0x8665
movq %rbx, %rdi
callq 0x21e0
movq %rax, %rdi
callq 0x20f0
xorl %edi, %edi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O3/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 0x7121
movl %edi, %ebp
movl $0x1, %r12d
movq 0x51e9(%rip), %r15      # 0xc200
leaq 0x130a(%rip), %r14      # 0x8328
movslq %r12d, %rax
movq (%rbx,%rax,8), %rcx
cmpb $0x2d, (%rcx)
jne 0x7059
movzbl 0x1(%rcx), %ecx
addl $-0x6b, %ecx
cmpl $0xc, %ecx
ja 0x7112
movslq (%r14,%rcx,4), %rcx
addq %r14, %rcx
jmpq *%rcx
leal 0x1(%rax), %r12d
movq 0x8(%rbx,%rax,8), %rdi
callq 0x22f0
movl %eax, 0x5195(%rip)      # 0xc1ec
jmp 0x706c
testq %r15, %r15
jne 0x7103
movq %rcx, 0x5197(%rip)      # 0xc200
movq %rcx, %r15
incl %r12d
cmpl %ebp, %r12d
jl 0x701e
jmp 0x70fa
leal 0x1(%rax), %r12d
movq 0x8(%rbx,%rax,8), %rdi
callq 0x2260
movsd %xmm0, 0x5151(%rip)     # 0xc1e0
jmp 0x706c
leal 0x1(%rax), %r12d
movq 0x8(%rbx,%rax,8), %rdi
callq 0x22f0
movl %eax, 0x5143(%rip)      # 0xc1e8
jmp 0x706c
movb $0x1, 0x5176(%rip)      # 0xc224
jmp 0x706c
movb $0x1, 0x516e(%rip)      # 0xc225
leal 0x1(%rax), %r12d
movq 0x8(%rbx,%rax,8), %rax
movq %rax, 0x5149(%rip)      # 0xc210
jmp 0x706c
leal 0x1(%rax), %r12d
movq 0x8(%rbx,%rax,8), %rax
movq %rax, 0x513f(%rip)      # 0xc218
jmp 0x706c
movl $0x0, 0x50f3(%rip)      # 0xc1d8
leal 0x1(%rax), %r12d
movq 0x8(%rbx,%rax,8), %rax
movq %rax, 0x5113(%rip)      # 0xc208
jmp 0x706c
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
movq (%rbx), %rdi
leaq 0x159a(%rip), %rsi      # 0x86a7
callq 0x6eb8
movq (%rbx), %rdi
leaq 0x157b(%rip), %rsi      # 0x8697
callq 0x6eb8
movq (%rbx), %rdi
leaq 0x1556(%rip), %rsi      # 0x8681
callq 0x6eb8
// File: /workspace/github_cpp_makefile_star2_O3/t0mm4rx[P]piscine_cpp/day01/ex03/ZombieHorde.cpp
// Function: ZombieHorde::ZombieHorde(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, int)
ZombieHorde::ZombieHorde(std::string type, int n)
{
	this->n = n;
	this->type = type;
	this->zombies = new Zombie[n];
	for (int i = 0; i < n; i++)
	{
		this->zombies[i].setType(type);
		this->zombies[i].setName(this->randomName());
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x68, %rsp
movl %edx, %r13d
movq %rsi, %r15
movq %rdi, %r14
addq $0x10, %rdi
leaq 0x20(%r14), %r12
movq %r12, 0x10(%r14)
movq $0x0, 0x18(%r14)
movb $0x0, 0x20(%r14)
movl %edx, 0x8(%r14)
movq %rdi, 0x38(%rsp)
callq 0x1060
movslq %r13d, %rbx
movq %rbx, %rbp
shlq $0x6, %rbp
leaq 0x8(%rbp), %rax
testl %r13d, %r13d
movq $-0x1, %rdi
cmovnsq %rax, %rdi
movq %rdi, 0x30(%rsp)
callq 0x1030
movq %rbx, (%rax)
leaq 0x8(%rax), %rbx
testl %r13d, %r13d
je 0x178e
movq %rax, 0x8(%rsp)
movq %r12, (%rsp)
negq %rbp
xorl %r12d, %r12d
movq %rbx, 0x40(%rsp)
movq %rbx, %rdi
callq 0x135c
addq $-0x40, %r12
addq $0x40, %rbx
cmpq %r12, %rbp
jne 0x16c8
movq 0x40(%rsp), %rax
movq %rax, (%r14)
testl %r13d, %r13d
jle 0x1791
movl %r13d, %ebp
shlq $0x6, %rbp
xorl %r12d, %r12d
leaq 0x48(%rsp), %r13
movq (%r14), %rbx
leaq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq (%r15), %rsi
movq 0x8(%r15), %rdx
addq %rsi, %rdx
leaq 0x10(%rsp), %rdi
callq 0x1514
addq %r12, %rbx
movq %rbx, %rdi
leaq 0x10(%rsp), %rsi
callq 0x1504
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x174a
movq 0x20(%rsp), %rsi
incq %rsi
callq 0x10f0
movq (%r14), %rbx
movq %r13, %rdi
callq 0x183c
addq %r12, %rbx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x150a
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x177f
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x10f0
addq $0x40, %r12
cmpq %r12, %rbp
jne 0x16fd
jmp 0x1791
movq %rbx, (%r14)
addq $0x68, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %r12, (%rsp)
jmp 0x1814
movq %rax, %r14
movq 0x10(%rsp), %rdi
leaq 0x20(%rsp), %rax
cmpq %rax, %rdi
je 0x1817
movq 0x20(%rsp), %rsi
jmp 0x17d6
movq %rax, %r14
movq 0x48(%rsp), %rdi
leaq 0x58(%rsp), %rax
cmpq %rax, %rdi
je 0x1817
movq 0x58(%rsp), %rsi
incq %rsi
callq 0x10f0
jmp 0x1817
movq %rax, %r14
testq %r12, %r12
je 0x1803
negq %r12
movq 0x8(%rsp), %rbx
addq $-0x38, %rbx
leaq (%rbx,%r12), %rdi
callq 0x1cb2
addq $-0x40, %r12
jne 0x17f4
movq 0x8(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x1140
jmp 0x1817
movq %rax, %r14
movq 0x38(%rsp), %rax
movq (%rax), %rdi
cmpq (%rsp), %rdi
je 0x1834
movq (%rsp), %rax
movq (%rax), %rsi
incq %rsi
callq 0x10f0
movq %r14, %rdi
callq 0x1120
// File: /workspace/github_cpp_makefile_star2_O3/t0mm4rx[P]piscine_cpp/day01/ex03/main.cpp
// Function: main
int main()
{
	srand(time(0));
	ZombieHorde *horde_good;
	ZombieHorde *horde_evil;

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x48, %rsp
xorl %edi, %edi
callq 0x10b0
movl %eax, %edi
callq 0x10c0
movl $0x30, %edi
callq 0x10e0
movq %rax, %rbx
leaq 0x38(%rsp), %r14
movq %r14, -0x10(%r14)
leaq 0x37d(%rip), %rsi       # 0x209b
leaq 0x37a(%rip), %rdx       # 0x209f
leaq 0x28(%rsp), %rdi
callq 0x15aa
leaq 0x28(%rsp), %rsi
movq %rbx, %rdi
movl $0x5, %edx
callq 0x1640
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x1d58
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10f0
movl $0x30, %edi
callq 0x10e0
movq %rax, %r14
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
leaq 0x32a(%rip), %rsi       # 0x20a0
leaq 0x327(%rip), %rdx       # 0x20a4
leaq 0x8(%rsp), %rdi
callq 0x15aa
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
movl $0xa, %edx
callq 0x1640
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x1db0
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10f0
movq 0x2221(%rip), %r15      # 0x3fd8
leaq 0x2e7(%rip), %rsi       # 0x20a5
movl $0xa, %edx
movq %r15, %rdi
callq 0x1100
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x10d0
movsbl %al, %esi
movq %r15, %rdi
callq 0x1040
movq %rax, %rdi
callq 0x1070
movq %rbx, %rdi
callq 0x1b82
leaq 0x2af(%rip), %rsi       # 0x20b0
movl $0xa, %edx
movq %r15, %rdi
callq 0x1100
movq (%r15), %rax
movq -0x18(%rax), %rdi
addq %r15, %rdi
movl $0xa, %esi
callq 0x10d0
movsbl %al, %esi
movq %r15, %rdi
callq 0x1040
movq %rax, %rdi
callq 0x1070
movq %r14, %rdi
callq 0x1b82
movq %r14, %rdi
callq 0x1ada
movl $0x30, %esi
movq %r14, %rdi
callq 0x10f0
movq %rbx, %rdi
callq 0x1ada
movl $0x30, %esi
movq %rbx, %rdi
callq 0x10f0
xorl %eax, %eax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r15
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x1e94
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x10f0
jmp 0x1e94
movq %rax, %r15
movq %r14, %rbx
jmp 0x1eb8
movq %rax, %r15
movq 0x28(%rsp), %rdi
cmpq %r14, %rdi
je 0x1eb8
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x10f0
jmp 0x1eb8
movq %rax, %r15
movl $0x30, %esi
movq %rbx, %rdi
callq 0x10f0
movq %r15, %rdi
callq 0x1120
// File: /workspace/github_cpp_makefile_star2_O3/protonpopsicle[P]lang/src/compiler/ByteCoder.cpp
// Function: ByteCoder::getVar(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>)
char ByteCoder::getVar(std::string id) {
    switch (zoneMgr->getVarType(id)) {
        case BOOL:
            addOp(OP_GET_BOOL, zoneMgr->getVarIndex(id));
            return BOOL;
        case INT:
            addOp(OP_GET_INT, zoneMgr->getVarIndex(id));
            return INT;
        case STRING:
            addOp(OP_GET_STRING, zoneMgr->getVarIndex(id));
            return STRING;
    }
}

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movl %edx, %eax
xorb $0x1, %al
movl %ecx, %r8d
xorb $0x1, %r8b
orb %al, %r8b
jne 0x2bb0
movswl %si, %eax
leal -0x12c(%rax), %ecx
cmpl $0x3, %ecx
ja 0x2bcb
leaq 0x4463(%rip), %rax      # 0x7004
movslq (%rax,%rcx,4), %rcx
addq %rax, %rcx
jmpq *%rcx
movw $0x16, %ax
jmp 0x2bf7
orb %dl, %cl
jne 0x2c0e
movswl %si, %eax
cmpl $0x130, %eax            # imm = 0x130
je 0x2bdb
cmpl $0x131, %eax            # imm = 0x131
jne 0x2c01
movw $0x1b, %ax
jmp 0x2bf7
cmpl $0x3c, %eax
je 0x2be1
cmpl $0x3e, %eax
jne 0x2c01
movw $0x15, %ax
jmp 0x2bf7
movw $0x1a, %ax
jmp 0x2bf7
movw $0x14, %ax
jmp 0x2bf7
movw $0x18, %ax
jmp 0x2bf7
movw $0x19, %ax
jmp 0x2bf7
movw $0x17, %ax
movzwl %ax, %esi
xorl %edx, %edx
callq 0x24b2
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
movl $0x20, %edi
callq 0x20c0
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x4463(%rip), %rsi      # 0x708e
leaq 0x447f(%rip), %rdx      # 0x70b1
leaq 0x8(%rsp), %rdi
callq 0x339c
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x36ac
xorl %ebp, %ebp
leaq 0x815b(%rip), %rsi      # 0xadb0
leaq 0x33c(%rip), %rdx       # 0x2f98
movq %rbx, %rdi
callq 0x2240
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x2c7e
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2160
testb %bpl, %bpl
jne 0x2c88
jmp 0x2c90
movq %rax, %r14
movq %rbx, %rdi
callq 0x2100
movq %r14, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O3/protonpopsicle[P]lang/src/compiler/ByteCoder.cpp
// Function: ByteCoder::print(char)
void ByteCoder::print(char rhs) {
    switch (rhs) {
        case INT:
            addOp(OP_PRINT_INT, 0);
            break;
        case STRING:
            addOp(OP_PRINT_STRING, 0);
            break;
        default:
            throw Error("type mismatch in print statement");
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movw $0xe, %ax
cmpl $0x1, %esi
je 0x2cb4
cmpl $0x2, %esi
jne 0x2cc8
movw $0xf, %ax
movzwl %ax, %esi
xorl %edx, %edx
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x24b2
movl $0x20, %edi
callq 0x20c0
movq %rax, %rbx
leaq 0x18(%rsp), %r15
movq %r15, -0x10(%r15)
leaq 0x43cd(%rip), %rsi      # 0x70b2
leaq 0x43e6(%rip), %rdx      # 0x70d2
leaq 0x8(%rsp), %rdi
callq 0x339c
movb $0x1, %bpl
leaq 0x8(%rsp), %rsi
movq %rbx, %rdi
callq 0x36ac
xorl %ebp, %ebp
leaq 0x80a1(%rip), %rsi      # 0xadb0
leaq 0x282(%rip), %rdx       # 0x2f98
movq %rbx, %rdi
callq 0x2240
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r15, %rdi
je 0x2d38
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x2160
testb %bpl, %bpl
jne 0x2d42
jmp 0x2d4a
movq %rax, %r14
movq %rbx, %rdi
callq 0x2100
movq %r14, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O3/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 0x427f(%rip), %r15      # 0x70de
movq %rsi, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x21e0
movq 0x68(%r14), %rax
movl 0x54(%rax), %edx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x21e0
movq 0x68(%r14), %rax
movl 0x58(%rax), %edx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x21e0
movq 0x28(%r14), %rdx
subq 0x20(%r14), %rdx
sarq $0x5, %rdx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x21e0
movq 0x40(%r14), %rdx
subq 0x38(%r14), %rdx
sarq $0x3, %rdx
leaq 0x4213(%rip), %rsi      # 0x70d3
movq %rbx, %rdi
xorl %eax, %eax
callq 0x21e0
movq 0x28(%r14), %r12
subq 0x20(%r14), %r12
shrq $0x5, %r12
testl %r12d, %r12d
jle 0x2f0a
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
leaq 0x41ee(%rip), %r15      # 0x70d7
xorl %r13d, %r13d
movq 0x20(%r14), %rax
movq (%rax,%r13), %rdx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x21e0
addq $0x20, %r13
decq %r12
jne 0x2eec
movq 0x40(%r14), %r12
subq 0x38(%r14), %r12
shrq $0x3, %r12
testl %r12d, %r12d
jle 0x2f4f
andl $0x7fffffff, %r12d      # imm = 0x7FFFFFFF
leaq 0x41b2(%rip), %r15      # 0x70db
xorl %r13d, %r13d
movq 0x38(%r14), %rax
movswl (%rax,%r13,8), %edx
movl 0x4(%rax,%r13,8), %ecx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x21e0
incq %r13
cmpq %r13, %r12
jne 0x2f2c
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_cpp_makefile_star2_O3/protonpopsicle[P]lang/src/compiler/Lexer.cpp
// Function: Lexer::Lexer(_IO_FILE*)
Lexer::Lexer(FILE *f) {
    fp = f;
    peek = ' '; 
    line = 1;
    
    keywords.insert(std::make_pair("int", BASIC));
    keywords.insert(std::make_pair("string", BASIC));
    keywords.insert(std::make_pair("bool", BASIC));
    keywords.insert(std::make_pair("true", TRUE));
    keywords.insert(std::make_pair("false", FALSE));
    keywords.insert(std::make_pair("print", PRINT));
    keywords.insert(std::make_pair("if", IF));
    keywords.insert(std::make_pair("while", WHILE));
    keywords.insert(std::make_pair("do", DO));
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x18, %rsp
movq %rdi, %rbx
leaq 0x8(%rdi), %rax
movl $0x0, 0x8(%rdi)
xorl %ecx, %ecx
movq %rcx, 0x10(%rdi)
movq %rax, 0x18(%rdi)
movq %rax, 0x20(%rdi)
movq %rcx, 0x28(%rdi)
movq %rsi, 0x30(%rdi)
movb $0x20, 0x38(%rdi)
movl $0x1, 0x3c(%rdi)
leaq 0x3692(%rip), %rax      # 0x722f
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movl $0x103, 0x8(%rsi)       # imm = 0x103
callq 0x422c
leaq 0x365e(%rip), %rax      # 0x7216
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movl $0x103, 0x8(%rsi)       # imm = 0x103
movq %rbx, %rdi
callq 0x422c
leaq 0x3647(%rip), %rax      # 0x721d
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movl $0x103, 0x8(%rsi)       # imm = 0x103
movq %rbx, %rdi
callq 0x422c
leaq 0x362e(%rip), %rax      # 0x7222
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movl $0x104, 0x8(%rsi)       # imm = 0x104
movq %rbx, %rdi
callq 0x422c
leaq 0x3615(%rip), %rax      # 0x7227
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movl $0x105, 0x8(%rsi)       # imm = 0x105
movq %rbx, %rdi
callq 0x422c
leaq 0x35fd(%rip), %rax      # 0x722d
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movl $0x106, 0x8(%rsi)       # imm = 0x106
movq %rbx, %rdi
callq 0x422c
leaq 0x35e5(%rip), %rax      # 0x7233
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movl $0x107, 0x8(%rsi)       # imm = 0x107
movq %rbx, %rdi
callq 0x422c
leaq 0x35ca(%rip), %rax      # 0x7236
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movl $0x108, 0x8(%rsi)       # imm = 0x108
movq %rbx, %rdi
callq 0x422c
leaq 0x35b2(%rip), %rax      # 0x723c
leaq 0x8(%rsp), %rsi
movq %rax, (%rsi)
movl $0x109, 0x8(%rsi)       # imm = 0x109
movq %rbx, %rdi
callq 0x422c
addq $0x18, %rsp
popq %rbx
popq %r14
retq
jmp 0x3cb9
jmp 0x3cb9
jmp 0x3cb9
jmp 0x3cb9
jmp 0x3cb9
jmp 0x3cb9
jmp 0x3cb9
jmp 0x3cb9
movq %rax, %r14
movq %rbx, %rdi
callq 0x41b4
movq %r14, %rdi
callq 0x2250
// File: /workspace/github_cpp_makefile_star2_O3/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 0x4ed0
movq %r12, (%rbx)
movq %r15, 0x8(%rbx)
movq %r14, 0x10(%rbx)
movq %rbx, %rdi
callq 0x4540
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
movq %rax, %r14
movq 0x20(%rbx), %rdi
addq $0x30, %rbx
cmpq %rbx, %rdi
je 0x4537
movq (%rbx), %rsi
incq %rsi
callq 0x2160
movq %r14, %rdi
callq 0x2250
nop