LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/ComplexNetworks-DCC-FCUP[P]fase/IGtrie.cpp
// Function: IGtrie::expand()
void IGtrie::expand()
{
  maxLabels *= 2;
  labelPaths = (int**) realloc(labelPaths, sizeof(int*) * maxLabels);
  labelLeaf = (int*) realloc(labelLeaf, sizeof(int) * maxLabels);
  labelCount = (int*) realloc(labelCount, sizeof(int) * maxLabels);  
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movslq (%rdi), %rsi
leal (%rsi,%rsi), %eax
movl %eax, (%rdi)
movq 0x8(%rdi), %rdi
shlq $0x4, %rsi
callq 0x22b0
movq %rax, 0x8(%rbx)
movq 0x10(%rbx), %rdi
movslq (%rbx), %rsi
shlq $0x2, %rsi
callq 0x22b0
movq %rax, 0x10(%rbx)
movq 0x18(%rbx), %rdi
movslq (%rbx), %rsi
shlq $0x2, %rsi
callq 0x22b0
movq %rax, 0x18(%rbx)
popq %rbx
retq
nop
// File: /workspace/github_c_makefile_star2_O1/ComplexNetworks-DCC-FCUP[P]fase/IGtrie.cpp
// Function: IGtrie::insertLabel(int, long long, int)
int IGtrie::insertLabel(int labelNode, long long int label, int digits)
{
  if (labelPaths[labelNode][label & (LB_WORD_SIZE - 1)] == -1)
  {
    if (numLabels == maxLabels)
      expand();

    int newNode = numLabels++;
    labelPaths[newNode] = new int[LB_WORD_SIZE];
    memset(labelPaths[newNode], -1, sizeof(int) * LB_WORD_SIZE);
    labelPaths[labelNode][label & (LB_WORD_SIZE - 1)] = newNode;
    labelLeaf[newNode] = ((digits <= LB_WORD_LEN) ? digits : 0);
    labelCount[newNode] = 0;
  }

  int nextNode = labelPaths[labelNode][label & (LB_WORD_SIZE - 1)];

  if (!labelLeaf[nextNode])
    return insertLabel(nextNode, label >> LB_WORD_LEN, digits - LB_WORD_LEN);
  return nextNode;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebx
movq %rdx, %r14
movl %esi, %eax
movq %rdi, %r15
movq 0x8(%r15), %rcx
movslq %eax, %r12
movq (%rcx,%r12,8), %rax
movl %r14d, %r13d
andl $0xf, %r13d
movl %r13d, %ecx
cmpl $-0x1, (%rax,%rcx,4)
jne 0x48c4
movl 0x4(%r15), %eax
cmpl (%r15), %eax
jne 0x485f
movq %r15, %rdi
callq 0x47ca
movslq 0x4(%r15), %rbp
leal 0x1(%rbp), %eax
movl %eax, 0x4(%r15)
movl $0x40, %edi
callq 0x2030
movq 0x8(%r15), %rcx
movq %rax, (%rcx,%rbp,8)
movq 0x8(%r15), %rax
movq (%rax,%rbp,8), %rax
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, (%rax)
movdqu %xmm0, 0x30(%rax)
movdqu %xmm0, 0x20(%rax)
movdqu %xmm0, 0x10(%rax)
movq 0x8(%r15), %rax
movq (%rax,%r12,8), %rax
movl %ebp, (%rax,%r13,4)
cmpl $0x5, %ebx
movl $0x0, %eax
cmovll %ebx, %eax
movq 0x10(%r15), %rcx
movl %eax, (%rcx,%rbp,4)
movq 0x18(%r15), %rax
movl $0x0, (%rax,%rbp,4)
movq 0x8(%r15), %rax
movq 0x10(%r15), %rcx
movq (%rax,%r12,8), %rax
movslq (%rax,%r13,4), %rax
cmpl $0x0, (%rcx,%rax,4)
jne 0x48e6
sarq $0x4, %r14
addl $-0x4, %ebx
jmp 0x4833
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/ComplexNetworks-DCC-FCUP[P]fase/IGtrie.cpp
// Function: IGtrie::enumerateFrom(int, long long, long long, int, int)
void IGtrie::enumerateFrom(int currentNode, long long int label, long long int parLabel, int parSize, int remaining)
{
  if (remaining == 0)
  {
    enumeration.push_back(make_pair(label, labelCount[currentNode]));
    return;
  }

  int i;
  for (i = 0; i < LB_WORD_SIZE; i++)
    if (labelPaths[currentNode][i] != -1)
    {
      long long int tmpLabel = parLabel;
      int tmpSize = parSize;

      if (labelLeaf[labelPaths[currentNode][i]])
      {
        int digits = labelLeaf[labelPaths[currentNode][i]];
        tmpLabel |= (i << tmpSize);
        tmpSize += digits;
        enumerateFrom(labelPaths[currentNode][i], ((label << tmpSize) | tmpLabel), 0, 0, remaining - 1);
      }
      else
      {
        int digits = LB_WORD_LEN;
        tmpLabel |= (i << tmpSize);
        tmpSize += digits;
        enumerateFrom(labelPaths[currentNode][i], label, tmpLabel, tmpSize, remaining);
      }
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rdi, %rbx
testl %r9d, %r9d
je 0x49e7
movl %r8d, %r12d
movq %rcx, %r13
movslq %esi, %r15
movq %r9, 0x10(%rsp)
leal -0x1(%r9), %eax
movl %eax, 0xc(%rsp)
leal 0x4(%r12), %eax
movl %eax, 0x8(%rsp)
xorl %ebp, %ebp
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rax
movslq (%rax,%rbp,4), %rsi
cmpq $-0x1, %rsi
je 0x49dc
movl %ebp, %eax
movl %r12d, %ecx
shll %cl, %eax
movq 0x10(%rbx), %rcx
movl (%rcx,%rsi,4), %ecx
cltq
testl %ecx, %ecx
je 0x49c1
addl %r12d, %ecx
movq %r14, %rdx
shlq %cl, %rdx
orq %r13, %rax
orq %rdx, %rax
movq %rbx, %rdi
movq %rax, %rdx
xorl %ecx, %ecx
xorl %r8d, %r8d
movl 0xc(%rsp), %r9d
jmp 0x49d7
orq %r13, %rax
movq %rbx, %rdi
movq %r14, %rdx
movq %rax, %rcx
movl 0x8(%rsp), %r8d
movq 0x10(%rsp), %r9
callq 0x493c
incq %rbp
cmpq $0x10, %rbp
jne 0x497a
jmp 0x4a24
movq 0x18(%rbx), %rax
movslq %esi, %rcx
movl (%rax,%rcx,4), %eax
movq %r14, 0x18(%rsp)
movl %eax, 0x20(%rsp)
movq 0x28(%rbx), %rsi
cmpq 0x30(%rbx), %rsi
je 0x4a13
movups 0x18(%rsp), %xmm0
movups %xmm0, (%rsi)
addq $0x10, 0x28(%rbx)
jmp 0x4a24
addq $0x20, %rbx
leaq 0x18(%rsp), %rdx
movq %rbx, %rdi
callq 0x4ac8
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/ComplexNetworks-DCC-FCUP[P]fase/Isomorphism.cpp
// Function: Isomorphism::canonicalStrNauty(std::__cxx11::basic_string<char, std::char_traits<char>, std::allocator<char>>, char*)
void Isomorphism::canonicalStrNauty(std::string v, char *s) {

  int i, j, aux;

  for (int i=0; i<n; i++) {
    gv = GRAPHROW(g,i,m);
    EMPTYSET(gv,m);

    for (int j=0; j<n; j++)
      if(v[i*n + j] == '1')
        ADDELEMENT(gv,j);
  }

  nauty(g,lab,ptn,NULL,orbits,&options,&stats,
        workspace,WORKSPACE_SIZE,m,n,mm);
  
  aux=0;
  for (i=0; i<n; i++) {
    gv = GRAPHROW(mm,i,m); 
    for (j=0; j<n; j++)
      s[aux++] = ISELEMENT(gv,j)?'1':'0';
  }
  s[aux]=0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rdi, %r14
movl 0x4b04(%rdi), %r10d
leaq 0x83d9(%rip), %r15      # 0xd050
testl %r10d, %r10d
jle 0x4d16
leaq 0x4c80(%r14), %rax
xorl %ecx, %ecx
movslq 0x4b08(%r14), %rdi
movq %rcx, %rdx
imulq %rdi, %rdx
leaq (%rax,%rdx,4), %rdx
movq %rdx, 0x4c78(%r14)
leaq (%rdx,%rdi,4), %rdi
addq $-0x4, %rdi
cmpq %rdx, %rdi
jb 0x4cbb
movl $0x0, (%rdi)
addq $-0x4, %rdi
jmp 0x4caa
movl 0x4b04(%r14), %r9d
testl %r9d, %r9d
jle 0x4d03
movq (%rsi), %rdi
xorl %r8d, %r8d
imull %ecx, %r9d
movslq %r9d, %r9
addq %rdi, %r9
cmpb $0x31, (%r8,%r9)
jne 0x4cf4
movl %r8d, %r9d
andl $0x1f, %r9d
movl (%r15,%r9,4), %r9d
movl %r8d, %r10d
shrl $0x5, %r10d
orl %r9d, (%rdx,%r10,4)
movl 0x4b04(%r14), %r9d
incq %r8
cmpl %r9d, %r8d
jl 0x4ccd
incq %rcx
movslq 0x4b04(%r14), %r10
cmpq %r10, %rcx
jl 0x4c89
leaq 0x4c80(%r14), %rdi
leaq 0x4b0c(%r14), %rsi
leaq 0x4b84(%r14), %rdx
leaq 0x4bfc(%r14), %r8
leaq 0x4(%r14), %rax
movl 0x4b08(%r14), %r11d
movq %fs:0x0, %rcx
leaq -0x80(%rcx), %r13
leaq 0xe554(%rip), %rbp      # 0x132a8
leaq 0xe45d(%rip), %r9       # 0x131b8
xorl %r12d, %r12d
xorl %ecx, %ecx
pushq %r13
pushq %r10
pushq %r11
pushq $0x12c0                 # imm = 0x12C0
pushq %rax
pushq %rbp
callq 0x7984
addq $0x30, %rsp
cmpl $0x0, 0x4b04(%r14)
jle 0x4df9
xorl %eax, %eax
movslq 0x4b08(%r14), %rcx
imulq %rax, %rcx
leaq (,%rcx,4), %rcx
addq %r13, %rcx
movq %rcx, 0x4c78(%r14)
cmpl $0x0, 0x4b04(%r14)
jle 0x4de7
movslq %r12d, %rcx
addq %rbx, %rcx
xorl %edx, %edx
movq 0x4c78(%r14), %rsi
movl %edx, %edi
shrl $0x5, %edi
movl %edx, %r8d
andl $0x1f, %r8d
movl (%r15,%r8,4), %r8d
testl %r8d, (%rsi,%rdi,4)
sete %sil
xorb $0x31, %sil
movb %sil, (%rcx,%rdx)
incq %rdx
cmpl 0x4b04(%r14), %edx
jl 0x4db1
addl %edx, %r12d
incq %rax
movslq 0x4b04(%r14), %rcx
cmpq %rcx, %rax
jl 0x4d82
movslq %r12d, %r12
movb $0x0, (%rbx,%r12)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/ComplexNetworks-DCC-FCUP[P]fase/DynamicGraph.cpp
// Function: DynamicGraph::_deleteAux()
void DynamicGraph::_deleteAux() {
  int i;

  if (_adjM != NULL) {
    for (i = 0; i < _num_nodes; i++)
      if (_adjM[i] != NULL)
        delete[] _adjM[i];
    delete[] _adjM;
  }

  if (_hashM != NULL) {
    int j;
    for (i = 0; i < _num_nodes; i++) {
      if (_hash_out != NULL) {
        for (j = 0; j < _hash_out[i]; j++) {
          l_list* cur = _hashM[i][j], *prev;
          while (cur != NULL) {
            prev = cur;
            cur = cur->next;
            delete prev;
          }
        }
      }
   
      delete[] _hashM[i];
    }
    delete[] _hashM;
  }

  if (hybrid_ch != NULL) delete[] hybrid_ch;

  ready = false;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpq $0x0, 0x48(%rdi)
je 0x5187
cmpl $0x0, 0xc(%rbx)
jle 0x5179
xorl %r14d, %r14d
movq 0x48(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x516d
callq 0x2220
incq %r14
movslq 0xc(%rbx), %rax
cmpq %rax, %r14
jl 0x515b
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x5187
callq 0x2220
cmpq $0x0, 0x70(%rbx)
je 0x5213
cmpl $0x0, 0xc(%rbx)
jle 0x5205
xorl %r14d, %r14d
cmpq $0x0, 0x30(%rbx)
je 0x51e7
movq 0x30(%rbx), %rax
cmpl $0x0, (%rax,%r14,4)
jle 0x51e7
xorl %r15d, %r15d
movq 0x70(%rbx), %rax
movq (%rax,%r14,8), %rax
movq (%rax,%r15,8), %rdi
testq %rdi, %rdi
je 0x51d7
movq 0x8(%rdi), %r12
movl $0x10, %esi
callq 0x21a0
movq %r12, %rdi
testq %r12, %r12
jne 0x51c1
incq %r15
movq 0x30(%rbx), %rax
movslq (%rax,%r14,4), %rax
cmpq %rax, %r15
jl 0x51b0
movq 0x70(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x51f9
callq 0x2220
incq %r14
movslq 0xc(%rbx), %rax
cmpq %rax, %r14
jl 0x519b
movq 0x70(%rbx), %rdi
testq %rdi, %rdi
je 0x5213
callq 0x2220
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x5221
callq 0x2220
movb $0x0, 0x78(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/ComplexNetworks-DCC-FCUP[P]fase/DynamicGraph.cpp
// Function: DynamicGraph::zero()
void DynamicGraph::zero() {
  int i,j;
  _num_edges = 0;
  ready = false;

  for (i = 0; i < _num_nodes; i++) {
    _in[i] = 0;
    _out[i] = 0;
    _hash_out[i] = 0;
    _num_neighbours[i] = 0;

    _adjIn[i].clear();
    _adjOut[i].clear();
    _neighbours[i].clear();
  }
}

// Assembly:
movl $0x0, 0x10(%rdi)
movb $0x0, 0x78(%rdi)
cmpl $0x0, 0xc(%rdi)
jle 0x52c1
pushq %r15
pushq %r14
pushq %rbx
movq 0x20(%rdi), %rax
movq 0x28(%rdi), %rcx
movq 0x30(%rdi), %rdx
movq 0x38(%rdi), %rsi
movq 0x60(%rdi), %r8
movq 0x58(%rdi), %r9
movq 0x68(%rdi), %r10
movl $0x2, %r11d
xorl %ebx, %ebx
xorl %r14d, %r14d
movl %ebx, (%rax,%r14,4)
movl %ebx, (%rcx,%r14,4)
movl %ebx, (%rdx,%r14,4)
movl %ebx, (%rsi,%r14,4)
movq -0x8(%r8,%r11,4), %r15
cmpq %r15, (%r8,%r11,4)
je 0x528e
movq %r15, (%r8,%r11,4)
movq -0x8(%r9,%r11,4), %r15
cmpq %r15, (%r9,%r11,4)
je 0x529d
movq %r15, (%r9,%r11,4)
movq -0x8(%r10,%r11,4), %r15
cmpq %r15, (%r10,%r11,4)
je 0x52ac
movq %r15, (%r10,%r11,4)
incq %r14
movslq 0xc(%rdi), %r15
addq $0x6, %r11
cmpq %r15, %r14
jl 0x526f
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/ComplexNetworks-DCC-FCUP[P]fase/DynamicGraph.cpp
// Function: DynamicGraph::createGraph(int, GraphType)
void DynamicGraph::createGraph(int n, GraphType t) {
  _delete();
  
  int i;
  _num_nodes = n;
  _type = t;
  
  int tmp_log = 4 * (int)log2((double) n);
  _log_nodes = 1;
  while (_log_nodes < tmp_log)
    _log_nodes *= 2;
  _log_nodes--;
  
  _adjIn      = new vector<int>[n];
  _adjOut     = new vector<int>[n];
  _neighbours = new vector<int>[n];

  _in             = new int[n];
  _out            = new int[n];
  _num_neighbours = new int[n];
  _hash_out       = new int[n];

  zero();
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r14d
movl %esi, %ebp
movq %rdi, %rbx
callq 0x4ec2
movl %ebp, 0xc(%rbx)
movl %r14d, 0x8(%rbx)
cvtsi2sd %ebp, %xmm0
callq 0x22d0
cvttsd2si %xmm0, %eax
shll $0x2, %eax
movl $0x1, %edx
movl %edx, %ecx
leal (%rcx,%rcx), %edx
cmpl %eax, %ecx
jl 0x52f6
movslq %ebp, %r14
movl $0x18, %edx
movq %r14, %rax
mulq %rdx
movq %rax, %r15
seto %al
addq $0x8, %r15
movq $-0x1, %rdx
cmovbq %rdx, %r15
testb %al, %al
cmovneq %rdx, %r15
decl %ecx
movl %ecx, 0x18(%rbx)
movq %r15, %rdi
callq 0x2030
movq %rax, %r12
movq %r14, (%rax)
addq $0x8, %r12
movabsq $-0x5555555555555555, %r13 # imm = 0xAAAAAAAAAAAAAAAB
testl %ebp, %ebp
je 0x5376
leaq (%r14,%r14,2), %rax
leaq -0x18(,%rax,8), %rax
mulq %r13
shrq $0x4, %rdx
leaq (%rdx,%rdx,2), %rax
leaq 0x18(,%rax,8), %rdx
movq %r12, %rdi
xorl %esi, %esi
callq 0x20d0
movq %r12, 0x60(%rbx)
movq %r15, %rdi
callq 0x2030
leaq 0x8(%rax), %r12
movq %r14, (%rax)
testl %ebp, %ebp
je 0x53b6
leaq (%r14,%r14,2), %rax
leaq -0x18(,%rax,8), %rax
mulq %r13
shrq $0x4, %rdx
leaq (%rdx,%rdx,2), %rax
leaq 0x18(,%rax,8), %rdx
movq %r12, %rdi
xorl %esi, %esi
callq 0x20d0
movq %r12, 0x58(%rbx)
movq %r15, %rdi
callq 0x2030
leaq 0x8(%rax), %r15
movq %r14, (%rax)
testl %ebp, %ebp
je 0x53f6
leaq (%r14,%r14,2), %rax
leaq -0x18(,%rax,8), %rax
mulq %r13
shrq $0x4, %rdx
leaq (%rdx,%rdx,2), %rax
leaq 0x18(,%rax,8), %rdx
movq %r15, %rdi
xorl %esi, %esi
callq 0x20d0
movq %r15, 0x68(%rbx)
shlq $0x2, %r14
testl %ebp, %ebp
movq $-0x1, %r15
cmovnsq %r14, %r15
movq %r15, %rdi
callq 0x2030
movq %rax, 0x20(%rbx)
movq %r15, %rdi
callq 0x2030
movq %rax, 0x28(%rbx)
movq %r15, %rdi
callq 0x2030
movq %rax, 0x38(%rbx)
movq %r15, %rdi
callq 0x2030
movq %rax, 0x30(%rbx)
movq (%rbx), %rax
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmpq *0x20(%rax)
// File: /workspace/github_c_makefile_star2_O1/ComplexNetworks-DCC-FCUP[P]fase/DynamicGraph.cpp
// Function: DynamicGraph::addEdge(int, int)
void DynamicGraph::addEdge(int a, int b) {
  _adjOut[a].push_back(b);
  _out[a]++;

  _adjIn[b].push_back(a);
  _in[b]++;

  _num_edges++;

  if (!hasEdge(b, a)) {
    _neighbours[b].push_back(a);
    _num_neighbours[b]++;

    _neighbours[a].push_back(b);
    _num_neighbours[a]++;
  }
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
movl %esi, 0xc(%rsp)
movl %edx, 0x8(%rsp)
movq 0x58(%rdi), %rax
movslq %esi, %rcx
leaq (%rcx,%rcx,2), %rcx
leaq (%rax,%rcx,8), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x58eb
movl %edx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi)
jmp 0x58f5
leaq 0x8(%rsp), %rdx
callq 0x67f6
movq 0x28(%rbx), %rax
movslq 0xc(%rsp), %rcx
incl (%rax,%rcx,4)
movq 0x60(%rbx), %rax
movslq 0x8(%rsp), %rcx
leaq (%rcx,%rcx,2), %rcx
leaq (%rax,%rcx,8), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x592c
movl 0xc(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi)
jmp 0x5936
leaq 0xc(%rsp), %rdx
callq 0x67f6
movq 0x20(%rbx), %rax
movslq 0x8(%rsp), %rcx
incl (%rax,%rcx,4)
incl 0x10(%rbx)
movl 0x8(%rsp), %esi
movl 0xc(%rsp), %edx
movq (%rbx), %rax
movq %rbx, %rdi
callq *0x48(%rax)
testb %al, %al
jne 0x59e0
movq 0x68(%rbx), %rax
movslq 0x8(%rsp), %rcx
leaq (%rcx,%rcx,2), %rcx
leaq (%rax,%rcx,8), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x5989
movl 0xc(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi)
jmp 0x5993
leaq 0xc(%rsp), %rdx
callq 0x67f6
movq 0x38(%rbx), %rax
movslq 0x8(%rsp), %rcx
incl (%rax,%rcx,4)
movq 0x68(%rbx), %rax
movslq 0xc(%rsp), %rcx
leaq (%rcx,%rcx,2), %rcx
leaq (%rax,%rcx,8), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x59ca
movl 0x8(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi)
jmp 0x59d4
leaq 0x8(%rsp), %rdx
callq 0x67f6
movq 0x38(%rbx), %rax
movslq 0xc(%rsp), %rcx
incl (%rax,%rcx,4)
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/ComplexNetworks-DCC-FCUP[P]fase/DynamicGraph.cpp
// Function: DynamicGraph::rmEdge(int, int)
void DynamicGraph::rmEdge(int a, int b) {
  ready = false;

  if (!hasEdge(a, b)) return;

  _removeVector(_adjOut[a], b);
  _out[a]--;

  _removeVector(_adjIn[b], a);
  _in[b]--;

  _num_edges--;

  if (!hasEdge(b, a)) {
    _removeVector(_neighbours[a], b);
    _num_neighbours[a]--;
    _removeVector(_neighbours[b], a);
    _num_neighbours[b]--;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %edx, %r14d
movl %esi, %ebp
movq %rdi, %rbx
movb $0x0, 0x78(%rdi)
movq (%rdi), %rax
callq *0x48(%rax)
testb %al, %al
je 0x5a9e
movslq %ebp, %r12
leaq (%r12,%r12,2), %r15
shlq $0x3, %r15
movq 0x58(%rbx), %rsi
addq %r15, %rsi
movl %r14d, %edx
callq 0x5aae
movq 0x28(%rbx), %rax
movq %r12, (%rsp)
decl (%rax,%r12,4)
movslq %r14d, %r13
leaq (,%r13,2), %r12
addq %r13, %r12
shlq $0x3, %r12
movq 0x60(%rbx), %rsi
addq %r12, %rsi
movl %ebp, %edx
callq 0x5aae
movq 0x20(%rbx), %rax
decl (%rax,%r13,4)
decl 0x10(%rbx)
movq (%rbx), %rax
movq %rbx, %rdi
movl %r14d, %esi
movl %ebp, %edx
callq *0x48(%rax)
testb %al, %al
jne 0x5a9e
addq 0x68(%rbx), %r15
movq %r15, %rsi
movl %r14d, %edx
callq 0x5aae
movq 0x38(%rbx), %rax
movq (%rsp), %rcx
decl (%rax,%rcx,4)
addq 0x68(%rbx), %r12
movq %r12, %rsi
movl %ebp, %edx
callq 0x5aae
movq 0x38(%rbx), %rax
decl (%rax,%r13,4)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/ComplexNetworks-DCC-FCUP[P]fase/DynamicGraph.cpp
// Function: DynamicGraph::hasEdge(int, int)
bool DynamicGraph::hasEdge(int a, int b) {
  if (!ready) {
    int i;
    for (i = 0; i < _out[a]; i++)
      if (_adjOut[a][i] == b)
        return true;
    return false;
  }

  if (!hybrid_ch[a])
    return _adjM[a][b];
  else if (_out[a] < 3) {
    int i;
    for (i = 0; i < _out[a]; i++)
      if (_adjOut[a][i] == b)
        return true;

    return false;
  }
  else {
    l_list* cur = _hashM[a][b & _hash_out[a]];
    while (cur != NULL) {
      if (cur->value == b)
        return true;

      cur = cur->next;
    }
    return false;
  }

  return false;
}

// Assembly:
movslq %esi, %rcx
cmpb $0x0, 0x78(%rdi)
je 0x5b53
movq 0x40(%rdi), %rax
cmpl $0x0, (%rax,%rcx,4)
je 0x5b82
movq 0x28(%rdi), %rax
movslq (%rax,%rcx,4), %rsi
cmpq $0x2, %rsi
jg 0x5b91
testl %esi, %esi
setg %al
jle 0x5b81
movq 0x58(%rdi), %rax
leaq (%rcx,%rcx,2), %rcx
movq (%rax,%rcx,8), %rax
xorl %ecx, %ecx
cmpl %edx, (%rax,%rcx,4)
je 0x5bba
incq %rcx
cmpq %rcx, %rsi
jne 0x5b44
jmp 0x5b7e
movq 0x28(%rdi), %rax
movslq (%rax,%rcx,4), %rsi
testq %rsi, %rsi
setg %al
jle 0x5b81
movq 0x58(%rdi), %rax
leaq (%rcx,%rcx,2), %rcx
movq (%rax,%rcx,8), %rax
xorl %ecx, %ecx
cmpl %edx, (%rax,%rcx,4)
je 0x5bba
incq %rcx
cmpq %rcx, %rsi
jne 0x5b71
seta %al
retq
movq 0x48(%rdi), %rax
movq (%rax,%rcx,8), %rax
movslq %edx, %rcx
movb (%rax,%rcx), %al
retq
movq 0x30(%rdi), %rax
movq 0x70(%rdi), %rsi
movq (%rsi,%rcx,8), %rsi
movl (%rax,%rcx,4), %eax
andl %edx, %eax
cltq
movq (%rsi,%rax,8), %rcx
testq %rcx, %rcx
setne %al
je 0x5b81
cmpl %edx, (%rcx)
je 0x5bba
movq 0x8(%rcx), %rcx
jmp 0x5ba8
movb $0x1, %al
retq
nop
// File: /workspace/github_c_makefile_star2_O1/ComplexNetworks-DCC-FCUP[P]fase/DynamicGraph.cpp
// Function: DynamicGraph::makeArrayNeighbours()
void DynamicGraph::makeArrayNeighbours() {
  int i,j;
  vector<int>:: iterator ii;
  _array_neighbours = new int*[_num_nodes];  
  for (i = 0; i < _num_nodes; i++) {
    _array_neighbours[i] = new int[_neighbours[i].size()];
    for (ii = _neighbours[i].begin(), j = 0; ii != _neighbours[i].end(); ii++, j++)
      _array_neighbours[i][j] = *ii;
    _neighbours[i].clear();
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq 0xc(%rdi), %rax
leaq (,%rax,8), %rdi
testq %rax, %rax
movq $-0x1, %r14
cmovsq %r14, %rdi
callq 0x2030
movq %rax, 0x50(%rbx)
cmpl $0x0, 0xc(%rbx)
jle 0x5d23
xorl %r15d, %r15d
movq 0x68(%rbx), %rax
leaq (,%r15,8), %rcx
leaq (%rcx,%rcx,2), %r12
movq 0x8(%rax,%r12), %rdi
subq (%rax,%r12), %rdi
cmovsq %r14, %rdi
callq 0x2030
movq 0x50(%rbx), %rcx
movq %rax, (%rcx,%r15,8)
movq 0x68(%rbx), %rax
movq (%rax,%r12), %rcx
movq 0x8(%rax,%r12), %rdx
cmpq %rdx, %rcx
je 0x5d0b
movq 0x50(%rbx), %rsi
movq (%rsi,%r15,8), %rsi
movq %rcx, %rdi
movl (%rdi), %r8d
movl %r8d, (%rsi)
addq $0x4, %rdi
addq $0x4, %rsi
cmpq %rdx, %rdi
jne 0x5cf8
cmpq %rcx, %rdx
je 0x5d17
addq %r12, %rax
movq %rcx, 0x8(%rax)
incq %r15
movslq 0xc(%rbx), %rax
cmpq %rax, %r15
jl 0x5cb1
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/ComplexNetworks-DCC-FCUP[P]fase/DynamicGraph.cpp
// Function: DynamicGraph::makeVectorNeighbours()
void DynamicGraph::makeVectorNeighbours() {
  int i,j;
  vector<int>:: iterator ii;

  for (i = 0; i < _num_nodes; i++)
    for (j = 0; j < _num_neighbours[i]; j++)
      _neighbours[i].push_back(_array_neighbours[i][j]);

  if (_array_neighbours!=NULL) {
    for (i = 0; i < _num_nodes; i++)
      if (_array_neighbours[i] != NULL)
        delete[] _array_neighbours[i];
    delete[] _array_neighbours;
  }
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
cmpl $0x0, 0xc(%rdi)
jle 0x5daa
xorl %r14d, %r14d
movq 0x38(%rbx), %rax
cmpl $0x0, (%rax,%r14,4)
jle 0x5d9e
leaq (%r14,%r14,2), %r15
xorl %r12d, %r12d
xorl %r13d, %r13d
movq 0x50(%rbx), %rax
movq 0x68(%rbx), %rcx
leaq (%rcx,%r15,8), %rdi
movq (%rax,%r14,8), %rdx
addq %r12, %rdx
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x5d85
movl (%rdx), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi)
jmp 0x5d8a
callq 0x67f6
incq %r13
movq 0x38(%rbx), %rax
movslq (%rax,%r14,4), %rax
addq $0x4, %r12
cmpq %rax, %r13
jl 0x5d5a
incq %r14
movslq 0xc(%rbx), %rax
cmpq %rax, %r14
jl 0x5d45
cmpq $0x0, 0x50(%rbx)
je 0x5def
cmpl $0x0, 0xc(%rbx)
jle 0x5dd8
xorl %r14d, %r14d
movq 0x50(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x5dcc
callq 0x2220
incq %r14
movslq 0xc(%rbx), %rax
cmpq %rax, %r14
jl 0x5dba
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x5def
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2220
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/ComplexNetworks-DCC-FCUP[P]fase/FaseMain.cpp
// Function: initSamplingProbabilities(Fase*)
void initSamplingProbabilities(Fase* fase)
{
  int i;
  prob = 1.0;
  for (i = 0; i < K; i++)
    prob *= sampProb[i];

  if (samp && fabs(prob) > 10e-7)
    fase->initSampling(K, sampProb);
  else
    prob = 1.0;
}

// Assembly:
movabsq $0x3ff0000000000000, %rax # imm = 0x3FF0000000000000
movq %rax, 0x72cc(%rip)      # 0x13640
movslq 0x7215(%rip), %rsi      # 0x13590
testq %rsi, %rsi
jle 0xc3b0
leaq (,%rsi,8), %rcx
movsd 0x19d8(%rip), %xmm0     # 0xdd68
xorl %edx, %edx
leaq 0x7207(%rip), %r8       # 0x135a0
mulsd (%rdx,%r8), %xmm0
addq $0x8, %rdx
cmpq %rdx, %rcx
jne 0xc399
movsd %xmm0, 0x7290(%rip)     # 0x13640
cmpb $0x1, 0x7294(%rip)      # 0x1364b
jne 0xc3df
movsd 0x727f(%rip), %xmm0     # 0x13640
andpd 0x19c7(%rip), %xmm0     # 0xdd90
ucomisd 0x199f(%rip), %xmm0     # 0xdd70
jbe 0xc3df
leaq 0x71c6(%rip), %rdx      # 0x135a0
jmp 0x29d6
movq %rax, 0x725a(%rip)      # 0x13640
retq
// File: /workspace/github_c_makefile_star2_O1/ComplexNetworks-DCC-FCUP[P]fase/FaseMain.cpp
// Function: main
int main(int argc, char **argv)
{
  init();
  read(argc, argv);

  if (K <= 2 || K >= MAXMOTIF)
  {
    fprintf(stderr, "Subgraph size needs to be between 3 and %d...\n", MAXMOTIF - 1);
    return 1;
  }

  Random::init(time(NULL));
  Fase* fase = new Fase(G, dir);
  initSamplingProbabilities(fase);

  Timer::start();
  fase->runCensus(K);
  Timer::stop();

  output(fase);
  finish(fase);
  
  return 0;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movl %edi, %ebp
leaq 0x183c(%rip), %rdi      # 0xe089
callq 0x2270
xorl %edi, %edi
callq 0x2150
movq %rax, 0x6f90(%rip)      # 0x137f0
movl %ebp, %edi
movq %rbx, %rsi
callq 0xbed5
movl 0x6d20(%rip), %eax      # 0x13590
addl $-0x14, %eax
cmpl $-0x12, %eax
jbe 0xc8e2
xorl %ebx, %ebx
xorl %edi, %edi
callq 0x2150
movl %eax, %edi
callq 0x7914
movl $0x3c8, %edi            # imm = 0x3C8
callq 0x2190
movq %rax, %r14
movq 0x6cec(%rip), %rsi      # 0x13588
movzbl 0x6da5(%rip), %edx      # 0x13648
movq %rax, %rdi
callq 0x283c
movq %r14, %rdi
callq 0xc363
callq 0x4e10
movl 0x6cd2(%rip), %esi      # 0x13590
movq %r14, %rdi
callq 0x29fc
callq 0x4e1e
movq %r14, %rdi
callq 0xc3e7
movq %r14, %rdi
callq 0xc803
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
callq 0x25cf
movl $0x1, %ebx
jmp 0xc8db
movq %rax, %rbx
movl $0x3c8, %esi            # imm = 0x3C8
movq %r14, %rdi
callq 0x21a0
movq %rbx, %rdi
callq 0x22c0
// File: /workspace/github_c_makefile_star2_O1/bokunimowakaru[P]petit15term/petitPanCake.c
// Function: open_serial_port
int open_serial_port(){
	struct termios ComTio;							// シリアル端末設定用の構造体変数
	speed_t speed = B115200;						// 通信速度の設定
	char modem_dev[15]="/dev/ttyUSBx";				// シリアルポートの初期値
	int i;
	for(i=12;i>=-1;i--){
		if(i>=10) snprintf(&modem_dev[5],8,"rfcomm%1d",i-10);	// ポート探索(rfcomm0-2)
		else if(i>=0) snprintf(&modem_dev[5],8,"ttyUSB%1d",i);	// ポート探索(USB0～9)
		else snprintf(&modem_dev[5],8,"ttyAMA0");	// 拡張IOのUART端子に設定
		ComFd=open(modem_dev, O_RDWR|O_NONBLOCK);	// シリアルポートのオープン
		if(ComFd >= 0){ 							// オープン成功時
			printf("com=%s\n",modem_dev);			// 成功したシリアルポートを表示
			tcgetattr(ComFd, &ComTio_Bk);			// 現在のシリアル端末設定状態を保存
			ComTio.c_iflag = 0; 					// シリアル入力設定の初期化
			ComTio.c_oflag = 0; 					// シリアル出力設定の初期化
			ComTio.c_cflag = CLOCAL|CREAD|CS8;		// シリアル制御設定の初期化
			ComTio.c_lflag = 0; 					// シリアルローカル設定の初期化
			bzero(ComTio.c_cc,sizeof(ComTio.c_cc)); // シリアル特殊文字設定の初期化
			cfsetispeed(&ComTio, speed);			// シリアル入力の通信速度の設定
			cfsetospeed(&ComTio, speed);			// シリアル出力の通信速度の設定
			ComTio.c_cc[VMIN] = 0;					// リード待ち容量0バイト(待たない)
			ComTio.c_cc[VTIME] = 0; 				// リード待ち時間0.0秒(待たない)
			tcflush(ComFd,TCIFLUSH);				// バッファのクリア
			tcsetattr(ComFd, TCSANOW, &ComTio); 	// シリアル端末に設定
			break;									// forループを抜ける
		}
	}
	return ComFd;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movabsq $0x7842535579, %rax     # imm = 0x7842535579
leaq 0xd(%rsp), %rbx
movq %rax, 0x2(%rbx)
movabsq $0x7974742f7665642f, %rax # imm = 0x7974742F7665642F
movq %rax, -0x5(%rbx)
movl $0xd, %r13d
leaq 0xcba(%rip), %r14       # 0x2032
leaq 0x8(%rsp), %r15
leaq 0xcb8(%rip), %r12       # 0x203c
movabsq $0x30414d41797474, %rbp # imm = 0x30414D41797474
leal -0x1(%r13), %ecx
cmpl $0xa, %ecx
jl 0x13a8
leal -0xb(%r13), %ecx
movl $0x8, %esi
movq %rbx, %rdi
movq %r14, %rdx
jmp 0x13b7
testl %ecx, %ecx
js 0x13e1
movl $0x8, %esi
movq %rbx, %rdi
movq %r12, %rdx
xorl %eax, %eax
callq 0x10b0
movq %r15, %rdi
movl $0x802, %esi            # imm = 0x802
xorl %eax, %eax
callq 0x1140
movl %eax, 0x2d09(%rip)      # 0x40dc
testl %eax, %eax
jns 0x13e8
decl %r13d
jns 0x138e
jmp 0x1464
movq %rbp, 0xd(%rsp)
jmp 0x13be
leaq 0xc57(%rip), %rdi       # 0x2046
leaq 0x8(%rsp), %rsi
xorl %eax, %eax
callq 0x10a0
movl 0x2cdb(%rip), %edi      # 0x40dc
leaq 0x2cd8(%rip), %rsi      # 0x40e0
callq 0x1120
movaps 0xbfc(%rip), %xmm0      # 0x2010
leaq 0x1c(%rsp), %rbx
movups %xmm0, (%rbx)
xorps %xmm0, %xmm0
movups %xmm0, 0x11(%rbx)
movups %xmm0, 0x21(%rbx)
movq %rbx, %rdi
movl $0x1002, %esi           # imm = 0x1002
callq 0x1160
movq %rbx, %rdi
movl $0x1002, %esi           # imm = 0x1002
callq 0x1080
movw $0x0, 0x16(%rbx)
movl 0x2c8f(%rip), %edi      # 0x40dc
xorl %esi, %esi
callq 0x1090
movl 0x2c82(%rip), %edi      # 0x40dc
xorl %esi, %esi
movq %rbx, %rdx
callq 0x1130
movl 0x2c72(%rip), %eax      # 0x40dc
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/bokunimowakaru[P]petit15term/petitPanCake.c
// Function: read_serial_port
char read_serial_port(void){
	char c='\0';									// シリアル受信した文字の代入用
	fd_set ComReadFds;								// select命令用構造体ComReadFdを定義
	struct timeval tv;								// タイムアウト値の保持用
	FD_ZERO(&ComReadFds);							// ComReadFdの初期化
	FD_SET(ComFd, &ComReadFds); 					// ファイルディスクリプタを設定
	tv.tv_sec=0; tv.tv_usec=TXL_WAIT;
	if(select(ComFd+1, &ComReadFds, 0, 0, &tv)) read(ComFd, &c, 1); // データを受信
	// usleep(5000);								// 5msの(IchigoJam処理)待ち時間
	return c;										// 戻り値＝受信データ(文字変数c)
}

// Assembly:
subq $0xa8, %rsp
xorps %xmm0, %xmm0
leaq 0x20(%rsp), %rsi
movaps %xmm0, (%rsi)
movaps %xmm0, 0x10(%rsi)
movaps %xmm0, 0x20(%rsi)
movaps %xmm0, 0x30(%rsi)
movaps %xmm0, 0x40(%rsi)
movaps %xmm0, 0x50(%rsi)
movaps %xmm0, 0x60(%rsi)
movaps %xmm0, 0x70(%rsi)
movl 0x2c2f(%rip), %edi      # 0x40dc
leal 0x3f(%rdi), %eax
testl %edi, %edi
cmovnsl %edi, %eax
movl %eax, %edx
andl $-0x40, %edx
movl %edi, %ecx
subl %edx, %ecx
movl $0x1, %edx
shlq %cl, %rdx
sarl $0x6, %eax
cltq
orq %rdx, 0x20(%rsp,%rax,8)
movb $0x0, 0xf(%rsp)
leaq 0x10(%rsp), %r8
movq $0x0, (%r8)
cmpb $0x0, 0x2c34(%rip)      # 0x411c
movl $0x708, %eax            # imm = 0x708
movl $0x9c4, %ecx            # imm = 0x9C4
cmovneq %rax, %rcx
movq %rcx, 0x8(%r8)
incl %edi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x1110
testl %eax, %eax
je 0x151e
movl 0x2bcd(%rip), %edi      # 0x40dc
leaq 0xf(%rsp), %rsi
movl $0x1, %edx
callq 0x10d0
movb 0xf(%rsp), %al
addq $0xa8, %rsp
retq
// File: /workspace/github_c_makefile_star2_O1/bokunimowakaru[P]petit15term/petitPanCake.c
// Function: ahex2i
int ahex2i(char c){
	if(c>='0' && c<='9') return c-'0';
	if(c>='a' && c<='f') return c-'a'+10;
	if(c>='A' && c<='F') return c-'F'+10;
	return -1;
}

// Assembly:
movl %edi, %eax
leal -0x30(%rax), %ecx
cmpb $0x9, %cl
ja 0x1559
addl $-0x30, %eax
retq
leal -0x61(%rax), %ecx
cmpb $0x5, %cl
ja 0x1565
addl $-0x57, %eax
retq
leal -0x41(%rax), %ecx
addl $-0x3c, %eax
cmpb $0x6, %cl
movl $0xffffffff, %ecx       # imm = 0xFFFFFFFF
cmovbl %eax, %ecx
movl %ecx, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/sebbekarlsson[P]cola/src/ast_node.c
// Function: init_ast_node
ast_node* init_ast_node(token* tok) {
    ast_node* ast;
    ast = calloc(1, sizeof(ast_node));
    ast->sc = malloc(sizeof(scope));
    ast->tok = tok;

    return ast;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl $0x1, %edi
movl $0x18, %esi
callq 0x10b0
movq %rax, %r14
movl $0x18, %edi
callq 0x10e0
movq %rax, 0x10(%r14)
movq %rbx, 0x8(%r14)
movq %r14, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/sebbekarlsson[P]cola/src/ast_node_assign.c
// Function: init_ast_node_assign
ast_node_assign* init_ast_node_assign(token* tok, ast_node* left, ast_node* right) {
    ast_node_assign* ast;
    ast = calloc(1, sizeof(ast_node_assign));
    ast->tok = tok;
    ast->left = left;
    ast->right = right;
    ast->base.type = AST_TYPE_ASSIGN;

    return ast;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x1, %edi
movl $0x30, %esi
callq 0x10b0
movq %r15, 0x18(%rax)
movq %r14, 0x20(%rax)
movq %rbx, 0x28(%rax)
movl $0x10, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/sebbekarlsson[P]cola/src/ast_node_binop.c
// Function: init_ast_node_binop
ast_node_binop* init_ast_node_binop(token* tok, ast_node* left, ast_node* right) {
    ast_node_binop* ast;
    ast = calloc(1, sizeof(ast_node_binop));
    ast->tok = tok;
    ast->value = malloc(sizeof(char*));
    ast->left = left;
    ast->right = right;
    ast->base.type = AST_TYPE_BINOP;

    return ast;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x1, %edi
movl $0x38, %esi
callq 0x10b0
movq %rax, %r12
movq %r15, 0x18(%rax)
movl $0x8, %edi
callq 0x10e0
movq %rax, 0x20(%r12)
movq %r14, 0x28(%r12)
movq %rbx, 0x30(%r12)
movl $0x1, (%r12)
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/sebbekarlsson[P]cola/src/ast_node_char.c
// Function: init_ast_node_char
ast_node_char* init_ast_node_char(token* tok, char value) {
    ast_node_char* ast;
    ast = calloc(1, sizeof(ast_node_char));
    ast->tok = tok;
    ast->value = value;
    ast->base.type = AST_TYPE_CHAR;

    return ast;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl $0x1, %edi
movl $0x28, %esi
callq 0x10b0
movq %r14, 0x18(%rax)
movb %bl, 0x20(%rax)
movl $0x6, (%rax)
popq %rbx
popq %r14
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/sebbekarlsson[P]cola/src/ast_node_component.c
// Function: init_ast_node_component
ast_node_component* init_ast_node_component(token* tok, token* name, ast_node_compound* body, ss_vector* deps) {
    ast_node_component* ast;
    ast = calloc(1, sizeof(ast_node_component));
    ast->tok = tok;
    ast->name = name;
    ast->body = body;
    ast->deps = deps;
    ast->base.type = AST_TYPE_COMPONENT;

    return ast;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl $0x1, %edi
movl $0x38, %esi
callq 0x10b0
movq %r12, 0x18(%rax)
movq %r15, 0x20(%rax)
movq %r14, 0x28(%rax)
movq %rbx, 0x30(%rax)
movl $0x8, (%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/sebbekarlsson[P]cola/src/ast_node_compound.c
// Function: init_ast_node_compound
ast_node_compound* init_ast_node_compound(token* tok, ss_vector* nodes) {
    ast_node_compound* ast;
    ast = calloc(1, sizeof(ast_node_compound));
    ast->tok = tok;
    ast->nodes = nodes;
    ast->base.type = AST_TYPE_COMPOUND;

    return ast;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, %edi
movl $0x28, %esi
callq 0x10b0
movq %r14, 0x18(%rax)
movq %rbx, 0x20(%rax)
movl $0x7, (%rax)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/sebbekarlsson[P]cola/src/ast_node_else.c
// Function: init_ast_node_else
ast_node_else* init_ast_node_else(token* tok, ast_node_compound* body, struct ast_node_if* ifnode) {
    ast_node_else* ast;
    ast = calloc(1, sizeof(ast_node_else));
    ast->tok = tok;
    ast->body = body;
    ast->ifnode = ifnode;
    ast->base.type = AST_TYPE_ELSE;

    return ast;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x1, %edi
movl $0x30, %esi
callq 0x10b0
movq %r15, 0x18(%rax)
movq %r14, 0x20(%rax)
movq %rbx, 0x28(%rax)
movl $0xf, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/sebbekarlsson[P]cola/src/ast_node_empty.c
// Function: init_ast_node_empty
ast_node_empty* init_ast_node_empty(token* tok) {
    ast_node_empty* ast;
    ast = calloc(1, sizeof(ast_node_empty));
    ast->tok = tok;
    ast->base.type = AST_TYPE_EMPTY;

    return ast;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %edi
movl $0x20, %esi
callq 0x10b0
movq %rbx, 0x18(%rax)
movl $0x0, (%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/sebbekarlsson[P]cola/src/ast_node_float.c
// Function: init_ast_node_float
ast_node_float* init_ast_node_float(token* tok, float value) {
    ast_node_float* ast;
    ast = calloc(1, sizeof(ast_node_float));
    ast->tok = tok;
    ast->value = value;
    ast->base.type = AST_TYPE_FLOAT;

    return ast;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movss %xmm0, -0xc(%rbp)
movq %rdi, %rbx
movl $0x1, %edi
movl $0x28, %esi
callq 0x10b0
movq %rbx, 0x18(%rax)
movss -0xc(%rbp), %xmm0
movss %xmm0, 0x20(%rax)
movl $0x4, (%rax)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/sebbekarlsson[P]cola/src/ast_node_foreach.c
// Function: init_ast_node_foreach
ast_node_foreach* init_ast_node_foreach(
    token* tok,
    ast_node* iterable,
    token* value_name,
    ast_node_compound* body
) {
    ast_node_foreach* ast;
    ast = calloc(1, sizeof(ast_node_foreach));
    ast->tok = tok;
    ast->iterable = iterable;
    ast->value_name = value_name;
    ast->body = body;
    ast->base.type = AST_TYPE_FOREACH;

    return ast;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl $0x1, %edi
movl $0x38, %esi
callq 0x10b0
movq %r12, 0x18(%rax)
movq %r15, 0x20(%rax)
movq %r14, 0x28(%rax)
movq %rbx, 0x30(%rax)
movl $0x12, (%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/sebbekarlsson[P]cola/src/ast_node_function_call.c
// Function: init_ast_node_function_call
ast_node_function_call* init_ast_node_function_call(token* tok, ss_vector* args) {
    ast_node_function_call* ast;
    ast = calloc(1, sizeof(ast_node_function_call));
    ast->tok = tok;
    ast->args = args;
    ast->base.type = AST_TYPE_FUNCTION_CALL;

    return ast;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, %edi
movl $0x28, %esi
callq 0x10b0
movq %r14, 0x18(%rax)
movq %rbx, 0x20(%rax)
movl $0xa, (%rax)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/sebbekarlsson[P]cola/src/ast_node_function_definition.c
// Function: init_ast_node_function_definition
ast_node_function_definition* init_ast_node_function_definition(
    token* tok,
    int data_type,
    ss_vector* args,
    ast_node_compound* body
) {
    ast_node_function_definition* ast;
    ast = calloc(1, sizeof(ast_node_function_definition));
    ast->tok = tok;
    ast->data_type = data_type;
    ast->args = args;
    ast->body = body;
    ast->base.type = AST_TYPE_FUNCTION_DEFINITION;

    return ast;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %r15d
movq %rdi, %r12
movl $0x1, %edi
movl $0x40, %esi
callq 0x10b0
movq %r12, 0x18(%rax)
movl %r15d, 0x20(%rax)
movq %r14, 0x28(%rax)
movq %rbx, 0x30(%rax)
movl $0xc, (%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/sebbekarlsson[P]cola/src/ast_node_if.c
// Function: init_ast_node_if
ast_node_if* init_ast_node_if(token* tok, ast_node* expr, ast_node_compound* body, ast_node_else* elsenode) {
    ast_node_if* ast;
    ast = calloc(1, sizeof(ast_node_if));
    ast->tok = tok;
    ast->expr = expr;
    ast->body = body;
    ast->elsenode = elsenode;
    ast->base.type = AST_TYPE_IF;

    return ast;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl $0x1, %edi
movl $0x38, %esi
callq 0x10b0
movq %r12, 0x18(%rax)
movq %r15, 0x20(%rax)
movq %r14, 0x28(%rax)
movq %rbx, 0x30(%rax)
movl $0xe, (%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/sebbekarlsson[P]cola/src/ast_node_integer.c
// Function: init_ast_node_integer
ast_node_integer* init_ast_node_integer(token* tok, int value) {
    ast_node_integer* ast;
    ast = calloc(1, sizeof(ast_node_integer));
    ast->tok = tok;
    ast->value = value;
    ast->base.type = AST_TYPE_INTEGER;

    return ast;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
movl $0x1, %edi
movl $0x28, %esi
callq 0x10b0
movq %r14, 0x18(%rax)
movl %ebx, 0x20(%rax)
movl $0x3, (%rax)
popq %rbx
popq %r14
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/sebbekarlsson[P]cola/src/ast_node_return.c
// Function: init_ast_node_return
ast_node_return* init_ast_node_return(token* tok, ast_node* value) {
    ast_node_return* ast;
    ast = calloc(1, sizeof(ast_node_return));
    ast->tok = tok;
    ast->value = value;
    ast->base.type = AST_TYPE_RETURN;

    return ast;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, %edi
movl $0x28, %esi
callq 0x10b0
movq %r14, 0x18(%rax)
movq %rbx, 0x20(%rax)
movl $0x13, (%rax)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/sebbekarlsson[P]cola/src/ast_node_string.c
// Function: init_ast_node_string
ast_node_string* init_ast_node_string(token* tok, char* value) {
    ast_node_string* ast;
    ast = calloc(1, sizeof(ast_node_string));
    ast->tok = tok;
    ast->value = value;
    ast->base.type = AST_TYPE_STRING;

    return ast;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, %edi
movl $0x28, %esi
callq 0x10b0
movq %r14, 0x18(%rax)
movq %rbx, 0x20(%rax)
movl $0x5, (%rax)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/sebbekarlsson[P]cola/src/ast_node_unaryop.c
// Function: init_ast_node_unaryop
ast_node_unaryop* init_ast_node_unaryop(token* tok, ast_node* right) {
    ast_node_unaryop* ast;
    ast = calloc(1, sizeof(ast_node_unaryop));
    ast->tok = tok;
    ast->right = right;
    ast->base.type = AST_TYPE_UNARYOP;

    return ast;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl $0x1, %edi
movl $0x28, %esi
callq 0x10b0
movq %r14, 0x18(%rax)
movq %rbx, 0x20(%rax)
movl $0x2, (%rax)
popq %rbx
popq %r14
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/sebbekarlsson[P]cola/src/ast_node_variable_definition.c
// Function: init_ast_node_variable_definition
ast_node_variable_definition* init_ast_node_variable_definition(token* tok, int data_type, ast_node* value) {
    ast_node_variable_definition* ast;
    ast = calloc(1, sizeof(ast_node_variable_definition));
    ast->tok = tok;
    ast->data_type = data_type;
    ast->value = value;
    ast->base.type = AST_TYPE_VARIABLE_DEFINITION;

    return ast;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %r14d
movq %rdi, %r15
movl $0x1, %edi
movl $0x30, %esi
callq 0x10b0
movq %r15, 0x18(%rax)
movl %r14d, 0x20(%rax)
movq %rbx, 0x28(%rax)
movl $0xb, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/sebbekarlsson[P]cola/src/ast_node_vector.c
// Function: init_ast_node_vector
ast_node_vector* init_ast_node_vector(token* tok, int data_type, ss_vector* vector) {
    ast_node_vector* ast;
    ast = calloc(1, sizeof(ast_node_vector));
    ast->tok = tok;
    ast->data_type = data_type;
    ast->vector = vector;
    ast->base.type = AST_TYPE_VECTOR;

    return ast;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %r14d
movq %rdi, %r15
movl $0x1, %edi
movl $0x30, %esi
callq 0x10b0
movq %r15, 0x18(%rax)
movl %r14d, 0x20(%rax)
movq %rbx, 0x28(%rax)
movl $0x15, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/sebbekarlsson[P]cola/src/ast_node_while.c
// Function: init_ast_node_while
ast_node_while* init_ast_node_while(token* tok, ast_node* expr, ast_node_compound* body) {
    ast_node_while* ast;
    ast = calloc(1, sizeof(ast_node_while));
    ast->tok = tok;
    ast->expr = expr;
    ast->body = body;
    ast->base.type = AST_TYPE_WHILE;

    return ast;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl $0x1, %edi
movl $0x30, %esi
callq 0x10b0
movq %r15, 0x18(%rax)
movq %r14, 0x20(%rax)
movq %rbx, 0x28(%rax)
movl $0x11, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/sebbekarlsson[P]cola/src/data_type_utils.c
// Function: name_to_data_type
int name_to_data_type(char* name) {
    if (strcmp(name, "int") == 0) {
        return _DATA_TYPE_INTEGER;
    } else if (strcmp(name, "float") == 0) {
        return _DATA_TYPE_FLOAT;
    } else if (strcmp(name, "void") == 0) {
        return _DATA_TYPE_VOID;
    } else if (strcmp(name, "char") == 0) {
        return _DATA_TYPE_CHAR;
    } else if (strcmp(name, "string") == 0) {
        return _DATA_TYPE_STRING;
    } else if (strcmp(name, "vector") == 0) {
        return _DATA_TYPE_VECTOR;
    } else {
        return -1;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x3844(%rip), %rsi      # 0x5048
callq 0x10c0
testl %eax, %eax
je 0x1875
leaq 0x37f0(%rip), %rsi      # 0x5004
movq %rbx, %rdi
callq 0x10c0
testl %eax, %eax
je 0x187c
leaq 0x37e3(%rip), %rsi      # 0x500a
movq %rbx, %rdi
callq 0x10c0
testl %eax, %eax
je 0x1883
leaq 0x37d5(%rip), %rsi      # 0x500f
movq %rbx, %rdi
callq 0x10c0
testl %eax, %eax
je 0x188a
leaq 0x37c7(%rip), %rsi      # 0x5014
movq %rbx, %rdi
callq 0x10c0
testl %eax, %eax
je 0x1891
leaq 0x37bb(%rip), %rsi      # 0x501b
movq %rbx, %rdi
callq 0x10c0
movl %eax, %ecx
xorl %eax, %eax
negl %ecx
sbbl %eax, %eax
orl $0x2e, %eax
jmp 0x1896
movl $0x29, %eax
jmp 0x1896
movl $0x2a, %eax
jmp 0x1896
movl $0x2b, %eax
jmp 0x1896
movl $0x28, %eax
jmp 0x1896
movl $0x2d, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/sebbekarlsson[P]cola/src/default_scope_initialize.c
// Function: print
ast_node* _print(ss_vector* args) {
    for (int i = 0; i < args->size; i++) {
        ast_node* node = (ast_node*)args->items[i];

        if (node->type == AST_TYPE_INTEGER) {
            ast_node_integer* node_integer = (ast_node_integer*) node;
            printf("%d\n", node_integer->value);
        } else if (node->type == AST_TYPE_FLOAT) {
            ast_node_float* node_float = (ast_node_float*) node;
            printf("%f\n", node_float->value);
        } else if (node->type == AST_TYPE_CHAR) {
            ast_node_char* node_char = (ast_node_char*) node;
            printf("%c\n", node_char->value);
        } else if (node->type == AST_TYPE_STRING) {
            ast_node_string* node_string = (ast_node_string*) node;
            printf("%s\n", node_string->value);
        } else {
            printf("<%d>\n", (int)node->type);
        }
    }

    return (ast_node*) init_ast_node_empty((void*)0);
}

// Assembly:
cmpq $0x0, (%rdi)
je 0x1946
pushq %rbp
movq %rsp, %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x3762(%rip), %r14      # 0x5024
leaq 0x376f(%rip), %r12      # 0x5038
leaq 0x376c(%rip), %r13      # 0x503c
xorl %r15d, %r15d
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rax
movl (%rax), %esi
leal -0x3(%rsi), %ecx
cmpl $0x3, %ecx
ja 0x1922
movslq (%r14,%rcx,4), %rcx
addq %r14, %rcx
jmpq *%rcx
movl 0x20(%rax), %esi
leaq 0x373c(%rip), %rdi      # 0x5034
jmp 0x1929
movq 0x20(%rax), %rdi
callq 0x1050
jmp 0x1930
movsbl 0x20(%rax), %esi
movq %r13, %rdi
jmp 0x1929
xorps %xmm0, %xmm0
cvtss2sd 0x20(%rax), %xmm0
movq %r12, %rdi
movb $0x1, %al
callq 0x10a0
jmp 0x1930
leaq 0x3717(%rip), %rdi      # 0x5040
xorl %eax, %eax
callq 0x10a0
incq %r15
cmpq %r15, (%rbx)
ja 0x18d3
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
xorl %edi, %edi
jmp 0x1458
// File: /workspace/github_c_makefile_star2_O1/sebbekarlsson[P]cola/src/default_scope_initialize.c
// Function: strlen
ast_node* _strlen(ss_vector* args) {
    ast_node* _node = (ast_node*)args->items[0];

    if (_node->type != AST_TYPE_STRING)
        return (ast_node*) init_ast_node_empty((void*)0); 

    ast_node_string* node_string = (ast_node_string*) _node;

    int length = strlen(node_string->value);

    return (ast_node*) init_ast_node_integer(
        init_token(_INTEGER, ""),
        length
    );
}

// Assembly:
movq 0x8(%rdi), %rax
movq (%rax), %rax
cmpl $0x5, (%rax)
jne 0x198c
pushq %rbp
movq %rsp, %rbp
pushq %rbx
pushq %rax
movq 0x20(%rax), %rdi
callq 0x1090
movq %rax, %rbx
leaq 0x39b3(%rip), %rsi      # 0x5325
movl $0x2, %edi
callq 0x4a78
movq %rax, %rdi
movl %ebx, %esi
addq $0x8, %rsp
popq %rbx
popq %rbp
jmp 0x15c4
xorl %edi, %edi
jmp 0x1458