LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/ComplexNetworks-DCC-FCUP[P]fase/Fase.cpp
// Function: Fase::initSampling(int, double*)
void Fase::initSampling(int sz, double* _sampProb)
{
  int i;
  for (i = 0; i < sz; i++)
    sampProb[i] = _sampProb[i];

  sampling = true;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x3a42
movq -0x28(%rbp), %rax
movq -0x18(%rbp), %rcx
movslq -0x1c(%rbp), %rdx
movsd (%rcx,%rdx,8), %xmm0
movq 0x98(%rax), %rax
movslq -0x1c(%rbp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x3a0e
movq -0x28(%rbp), %rax
movb $0x1, 0x1(%rax)
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ComplexNetworks-DCC-FCUP[P]fase/Fase.cpp
// Function: Fase::runCensus(int)
void Fase::runCensus(int _K)
{
  K = _K;
  motifCount = 0;
  igtrie.init(K);

  for (int i = 0; i < graph->numNodes(); i++)
    if (!sampling || Random::testProb(sampProb[0]))
    {
      vsub[0] = i;
      int *nei = graph->arrayNeighbours(i);
      int neiNum = graph->numNeighbours(i);

      vextSz[1] = 0;
      for (int j = 0; j < neiNum; j++)
        if (nei[j] > i)
          vext[1][vextSz[1]++] = nei[j];
    
      expandEnumeration(1, 0, 0LL);
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
movl -0xc(%rbp), %ecx
movl %ecx, 0x10(%rax)
movl $0x0, 0x14(%rax)
movq %rax, %rdi
addq $0x18, %rdi
movl 0x10(%rax), %esi
callq 0x8ab0
movl $0x0, -0x10(%rbp)
movq -0x28(%rbp), %rax
movl -0x10(%rbp), %ecx
movl %ecx, -0x2c(%rbp)
movq 0x8(%rax), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movl %eax, %ecx
movl -0x2c(%rbp), %eax
cmpl %ecx, %eax
jge 0x3ba3
movq -0x28(%rbp), %rax
testb $0x1, 0x1(%rax)
je 0x3ad2
movq -0x28(%rbp), %rax
movq 0x98(%rax), %rax
movsd (%rax), %xmm0
callq 0x11d10
testb $0x1, %al
jne 0x3ad2
jmp 0x3b93
movq -0x28(%rbp), %rax
movl -0x10(%rbp), %edx
movq 0x90(%rax), %rcx
movl %edx, (%rcx)
movq 0x8(%rax), %rdi
movl -0x10(%rbp), %esi
movq (%rdi), %rax
callq *0xa8(%rax)
movq %rax, %rcx
movq -0x28(%rbp), %rax
movq %rcx, -0x18(%rbp)
movq 0x8(%rax), %rdi
movl -0x10(%rbp), %esi
movq (%rdi), %rax
callq *0x68(%rax)
movl %eax, %ecx
movq -0x28(%rbp), %rax
movl %ecx, -0x1c(%rbp)
movq 0x88(%rax), %rax
movl $0x0, 0x4(%rax)
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x3b7f
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rcx
movl (%rax,%rcx,4), %eax
cmpl -0x10(%rbp), %eax
jle 0x3b72
movq -0x28(%rbp), %rcx
movq -0x18(%rbp), %rax
movslq -0x20(%rbp), %rdx
movl (%rax,%rdx,4), %edx
movq 0x80(%rcx), %rax
movq 0x8(%rax), %rax
movq 0x88(%rcx), %rsi
movl 0x4(%rsi), %ecx
movl %ecx, %edi
addl $0x1, %edi
movl %edi, 0x4(%rsi)
movslq %ecx, %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x3b74
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x3b28
movq -0x28(%rbp), %rdi
movl $0x1, %esi
xorl %edx, %edx
xorl %eax, %eax
movl %eax, %ecx
callq 0x3bb0
jmp 0x3b95
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0x3a8a
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ComplexNetworks-DCC-FCUP[P]fase/Fase.cpp
// Function: Fase::getSubgraphFrequency(std::pair<long long, int>, Isomorphism*)
void Fase::getSubgraphFrequency(pair<long long int, int> element, Isomorphism* iso)
{
  Label::fillNautyMatrix(sadjM, K, element.first);

  nauty_s[0] = '\0';
  iso->canonicalStrNauty(sadjM, nauty_s);
  string str = string(nauty_s);
  canonicalTypes[str] += element.second;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xc0, %rsp
movq %rsi, -0x10(%rbp)
movl %edx, -0x8(%rbp)
movq %rdi, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq %rax, -0xa0(%rbp)
movq %rax, %rdi
addq $0xa0, %rdi
movq %rdi, -0x90(%rbp)
movl 0x10(%rax), %esi
movq -0x10(%rbp), %rdx
callq 0x87e0
movq -0xa0(%rbp), %rax
movb $0x0, 0x231(%rax)
movq -0x20(%rbp), %rax
movq %rax, -0x98(%rbp)
leaq -0x41(%rbp), %rdi
movq %rdi, -0x88(%rbp)
callq 0x3390
movq -0x90(%rbp), %rsi
movq -0x88(%rbp), %rdx
leaq -0x40(%rbp), %rdi
callq 0x44e0
jmp 0x4024
movq -0x98(%rbp), %rdi
movq -0xa0(%rbp), %rdx
addq $0x231, %rdx            # imm = 0x231
leaq -0x40(%rbp), %rsi
callq 0x9f40
jmp 0x4044
leaq -0x40(%rbp), %rdi
callq 0x3120
leaq -0x41(%rbp), %rdi
callq 0x3250
movq -0xa0(%rbp), %rax
addq $0x231, %rax            # imm = 0x231
movq %rax, -0xb0(%rbp)
leaq -0x79(%rbp), %rdi
movq %rdi, -0xa8(%rbp)
callq 0x3390
movq -0xb0(%rbp), %rsi
movq -0xa8(%rbp), %rdx
leaq -0x78(%rbp), %rdi
callq 0x44e0
jmp 0x4093
leaq -0x79(%rbp), %rdi
callq 0x3250
movq -0xa0(%rbp), %rdi
movl -0x8(%rbp), %eax
movl %eax, -0xbc(%rbp)
addq $0x50, %rdi
leaq -0x78(%rbp), %rsi
callq 0x4590
movq %rax, -0xb8(%rbp)
jmp 0x40c2
movq -0xb8(%rbp), %rax
movl -0xbc(%rbp), %ecx
addl (%rax), %ecx
movl %ecx, (%rax)
leaq -0x78(%rbp), %rdi
callq 0x3120
addq $0xc0, %rsp
popq %rbp
retq
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
jmp 0x4108
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x40(%rbp), %rdi
callq 0x3120
leaq -0x41(%rbp), %rdi
callq 0x3250
jmp 0x413f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x79(%rbp), %rdi
callq 0x3250
jmp 0x413f
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x50(%rbp)
movl %eax, -0x54(%rbp)
leaq -0x78(%rbp), %rdi
callq 0x3120
movq -0x50(%rbp), %rdi
callq 0x3380
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ComplexNetworks-DCC-FCUP[P]fase/Fase.cpp
// Function: Fase::reduceCanonicalTypes()
void Fase::reduceCanonicalTypes()
{
  if (!canonicalTypes.empty())
    return;

  Isomorphism *iso = new Isomorphism();
  iso->initNauty(K, directed);
  for (auto element : igtrie.enumerate(K))
    getSubgraphFrequency(element, iso);
  iso->finishNauty();
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x80, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x78(%rbp)
addq $0x50, %rdi
callq 0x4670
testb $0x1, %al
jne 0x4179
jmp 0x4265
movl $0x8100, %edi           # imm = 0x8100
callq 0x3210
movq %rax, %rdi
movq %rdi, -0x80(%rbp)
xorl %esi, %esi
movl $0x8100, %edx           # imm = 0x8100
callq 0x3100
movq -0x80(%rbp), %rcx
movq -0x78(%rbp), %rax
movq %rcx, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movl 0x10(%rax), %esi
movb (%rax), %al
andb $0x1, %al
movzbl %al, %edx
callq 0x9e60
movq -0x78(%rbp), %rax
movq %rax, %rsi
addq $0x18, %rsi
movl 0x10(%rax), %edx
leaq -0x30(%rbp), %rdi
callq 0x8d70
leaq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x4690
movq %rax, -0x38(%rbp)
movq -0x18(%rbp), %rdi
callq 0x46c0
movq %rax, -0x40(%rbp)
leaq -0x38(%rbp), %rdi
leaq -0x40(%rbp), %rsi
callq 0x46f0
testb $0x1, %al
jne 0x420a
leaq -0x30(%rbp), %rdi
callq 0x4770
jmp 0x425c
leaq -0x38(%rbp), %rdi
callq 0x4730
movq -0x78(%rbp), %rdi
movups (%rax), %xmm0
movaps %xmm0, -0x50(%rbp)
movaps -0x50(%rbp), %xmm0
movaps %xmm0, -0x60(%rbp)
movq -0x10(%rbp), %rcx
movq -0x60(%rbp), %rsi
movl -0x58(%rbp), %edx
callq 0x3fa0
jmp 0x4238
jmp 0x423a
leaq -0x38(%rbp), %rdi
callq 0x4750
jmp 0x41ee
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x68(%rbp)
movl %eax, -0x6c(%rbp)
leaq -0x30(%rbp), %rdi
callq 0x4770
jmp 0x426e
movq -0x10(%rbp), %rdi
callq 0x9f10
addq $0x80, %rsp
popq %rbp
retq
movq -0x68(%rbp), %rdi
callq 0x3380
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ComplexNetworks-DCC-FCUP[P]fase/Fase.cpp
// Function: Fase::subgraphCount[abi:cxx11]()
vector<pair<int, string> > Fase::subgraphCount()
{
  reduceCanonicalTypes();

  vector<pair<int, string> > subgraphVector;
  for (auto element : canonicalTypes)
    subgraphVector.push_back(make_pair(element.second, element.first));

  sort(subgraphVector.begin(), subgraphVector.end());
  reverse(subgraphVector.begin(), subgraphVector.end());

  return subgraphVector;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0xd0, %rsp
movq %rdi, -0xc0(%rbp)
movq %rdi, %rax
movq %rax, -0xc8(%rbp)
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movq -0x10(%rbp), %rdi
movq %rdi, -0xb8(%rbp)
callq 0x4150
movq -0xc0(%rbp), %rdi
movb $0x0, -0x11(%rbp)
callq 0x47f0
movq -0xb8(%rbp), %rax
addq $0x50, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rdi
callq 0x4810
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rdi
callq 0x4840
movq %rax, -0x30(%rbp)
leaq -0x28(%rbp), %rdi
leaq -0x30(%rbp), %rsi
callq 0x4870
testb $0x1, %al
jne 0x4333
jmp 0x43da
leaq -0x28(%rbp), %rdi
callq 0x48a0
movq %rax, %rsi
leaq -0x58(%rbp), %rdi
callq 0x48c0
jmp 0x434a
leaq -0x38(%rbp), %rsi
leaq -0x90(%rbp), %rdi
leaq -0x58(%rbp), %rdx
callq 0x4930
jmp 0x4360
movq -0xc0(%rbp), %rdi
leaq -0x90(%rbp), %rsi
callq 0x4900
jmp 0x4375
leaq -0x90(%rbp), %rdi
callq 0x4970
leaq -0x58(%rbp), %rdi
callq 0x4990
leaq -0x28(%rbp), %rdi
callq 0x49b0
jmp 0x431d
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x4476
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
jmp 0x43cc
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x60(%rbp)
movl %eax, -0x64(%rbp)
leaq -0x90(%rbp), %rdi
callq 0x4970
leaq -0x58(%rbp), %rdi
callq 0x4990
jmp 0x4476
movq -0xc0(%rbp), %rdi
callq 0x4a20
movq -0xc0(%rbp), %rdi
movq %rax, -0x98(%rbp)
callq 0x4a50
movq %rax, -0xa0(%rbp)
movq -0x98(%rbp), %rdi
movq -0xa0(%rbp), %rsi
callq 0x49e0
jmp 0x4415
movq -0xc0(%rbp), %rdi
callq 0x4a20
movq -0xc0(%rbp), %rdi
movq %rax, -0xa8(%rbp)
callq 0x4a50
movq %rax, -0xb0(%rbp)
movq -0xa8(%rbp), %rdi
movq -0xb0(%rbp), %rsi
callq 0x4a80
jmp 0x4450
movb $0x1, -0x11(%rbp)
testb $0x1, -0x11(%rbp)
jne 0x4466
movq -0xc0(%rbp), %rdi
callq 0x4ac0
movq -0xc8(%rbp), %rax
addq $0xd0, %rsp
popq %rbp
retq
movq -0xc0(%rbp), %rdi
callq 0x4ac0
movq -0x60(%rbp), %rdi
callq 0x3380
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ComplexNetworks-DCC-FCUP[P]fase/Label.cpp
// Function: Label::updateLabel(int*, int, int)
long long int Label::updateLabel(int* vsub, int currentVertex, int depth)
{
  long long int label = 0;

  if (directed)
  {
    for (int i = 0; i < depth; i++)
    {
      label |= ((1LL << (2 * i)) * graph->hasEdge(vsub[i], currentVertex));
      label |= ((1LL << (2 * i + 1)) * graph->hasEdge(currentVertex, vsub[i]));
    }
  }
  else
  {
    for (int i = 0; i < depth; i++)
      label |= ((1LL << i) * graph->isConnected(vsub[i], currentVertex));
  }

  return label;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq $0x0, -0x18(%rbp)
testb $0x1, 0x1a697(%rip)     # 0x22d18
je 0x873d
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x873b
movl -0x1c(%rbp), %eax
shll %eax
movl %eax, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, -0x30(%rbp)
movq 0x1a65a(%rip), %rdi     # 0x22d10
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %esi
movl -0xc(%rbp), %edx
movq (%rdi), %rax
callq *0x48(%rax)
movb %al, %cl
movq -0x30(%rbp), %rax
andb $0x1, %cl
movzbl %cl, %ecx
imulq %rcx, %rax
orq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
shll %eax
addl $0x1, %eax
movl %eax, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, -0x28(%rbp)
movq 0x1a60f(%rip), %rdi     # 0x22d10
movl -0xc(%rbp), %esi
movq -0x8(%rbp), %rax
movslq -0x1c(%rbp), %rcx
movl (%rax,%rcx,4), %edx
movq (%rdi), %rax
callq *0x48(%rax)
movb %al, %cl
movq -0x28(%rbp), %rax
andb $0x1, %cl
movzbl %cl, %ecx
imulq %rcx, %rax
orq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x868e
jmp 0x879d
movl $0x0, -0x20(%rbp)
movl -0x20(%rbp), %eax
cmpl -0x10(%rbp), %eax
jge 0x879b
movl -0x20(%rbp), %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, -0x38(%rbp)
movq 0x1a5ac(%rip), %rdi     # 0x22d10
movq -0x8(%rbp), %rax
movslq -0x20(%rbp), %rcx
movl (%rax,%rcx,4), %esi
movl -0xc(%rbp), %edx
movq (%rdi), %rax
callq *0x50(%rax)
movb %al, %cl
movq -0x38(%rbp), %rax
andb $0x1, %cl
movzbl %cl, %ecx
imulq %rcx, %rax
orq -0x18(%rbp), %rax
movq %rax, -0x18(%rbp)
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0x8744
jmp 0x879d
movq -0x18(%rbp), %rax
addq $0x40, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ComplexNetworks-DCC-FCUP[P]fase/IGtrie.cpp
// Function: IGtrie::destroy()
void IGtrie::destroy()
{
  if (!numLabels)
    return;

  int i;
  for (i = 0; i < numLabels; i++)
    delete[] labelPaths[i];

  free(labelPaths);
  free(labelLeaf);
  free(labelCount);
  numLabels = 0;
  maxLabels = 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
cmpl $0x0, 0x4(%rax)
jne 0x8a2c
jmp 0x8aa7
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0x4(%rcx), %eax
jge 0x8a6f
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
cmpq $0x0, %rax
je 0x8a62
movq -0x20(%rbp), %rdi
callq 0x32f0
jmp 0x8a64
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x8a33
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rdi
callq 0x32a0
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rdi
callq 0x32a0
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rdi
callq 0x32a0
movq -0x18(%rbp), %rax
movl $0x0, 0x4(%rax)
movl $0x0, (%rax)
addq $0x20, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ComplexNetworks-DCC-FCUP[P]fase/IGtrie.cpp
// Function: IGtrie::init(int)
void IGtrie::init(int K)
{
  maxLabels = 10 * K * K;
  numLabels = 1;
  labelPaths = (int**) malloc(sizeof(int*) * maxLabels);
  labelLeaf = (int*) malloc(sizeof(int) * maxLabels);
  labelCount = (int*) malloc(sizeof(int) * maxLabels);

  labelPaths[0] = new int[LB_WORD_SIZE];
  labelLeaf[0] = 1;
  labelCount[0] = 0;
  memset(labelPaths[0], -1, sizeof(int) * LB_WORD_SIZE);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
imull $0xa, -0xc(%rbp), %ecx
imull -0xc(%rbp), %ecx
movl %ecx, (%rax)
movl $0x1, 0x4(%rax)
movslq (%rax), %rdi
shlq $0x3, %rdi
callq 0x3300
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x8(%rax)
movslq (%rax), %rdi
shlq $0x2, %rdi
callq 0x3300
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movslq (%rax), %rdi
shlq $0x2, %rdi
callq 0x3300
movq %rax, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movl $0x40, %edi
callq 0x3030
movq %rax, %rdx
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rcx
movq %rdx, (%rcx)
movq 0x10(%rax), %rcx
movl $0x1, (%rcx)
movq 0x18(%rax), %rcx
movl $0x0, (%rcx)
movq 0x8(%rax), %rax
movq (%rax), %rdi
movl $0xff, %esi
movl $0x40, %edx
callq 0x3100
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x10(%rbp)
movl (%rax), %ecx
shll %ecx
movl %ecx, (%rax)
movq 0x8(%rax), %rdi
movslq (%rax), %rsi
shlq $0x3, %rsi
callq 0x3370
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rax), %rdi
movslq (%rax), %rsi
shlq $0x2, %rsi
callq 0x3370
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq 0x18(%rax), %rdi
movslq (%rax), %rsi
shlq $0x2, %rsi
callq 0x3370
movq %rax, %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movq %rdx, -0x20(%rbp)
movl %ecx, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x38(%rbp)
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x20(%rbp), %rcx
andq $0xf, %rcx
cmpl $-0x1, (%rax,%rcx,4)
jne 0x8d0e
movq -0x38(%rbp), %rcx
movl 0x4(%rcx), %eax
cmpl (%rcx), %eax
jne 0x8c70
movq -0x38(%rbp), %rdi
callq 0x8b70
movq -0x38(%rbp), %rcx
movl 0x4(%rcx), %eax
movl %eax, %edx
addl $0x1, %edx
movl %edx, 0x4(%rcx)
movl %eax, -0x28(%rbp)
movl $0x40, %edi
callq 0x3030
movq %rax, %rsi
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rcx
movslq -0x28(%rbp), %rdx
movq %rsi, (%rcx,%rdx,8)
movq 0x8(%rax), %rax
movslq -0x28(%rbp), %rcx
movq (%rax,%rcx,8), %rdi
movl $0xff, %esi
movl $0x40, %edx
callq 0x3100
movq -0x38(%rbp), %rax
movl -0x28(%rbp), %edx
movq 0x8(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq -0x20(%rbp), %rcx
andq $0xf, %rcx
movl %edx, (%rax,%rcx,4)
cmpl $0x4, -0x24(%rbp)
jg 0x8ce6
movl -0x24(%rbp), %eax
movl %eax, -0x3c(%rbp)
jmp 0x8ced
xorl %eax, %eax
movl %eax, -0x3c(%rbp)
jmp 0x8ced
movq -0x38(%rbp), %rax
movl -0x3c(%rbp), %esi
movq 0x10(%rax), %rcx
movslq -0x28(%rbp), %rdx
movl %esi, (%rcx,%rdx,4)
movq 0x18(%rax), %rax
movslq -0x28(%rbp), %rcx
movl $0x0, (%rax,%rcx,4)
movq -0x38(%rbp), %rax
movq 0x8(%rax), %rcx
movslq -0x14(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movq -0x20(%rbp), %rdx
andq $0xf, %rdx
movl (%rcx,%rdx,4), %ecx
movl %ecx, -0x2c(%rbp)
movq 0x10(%rax), %rax
movslq -0x2c(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jne 0x8d59
movq -0x38(%rbp), %rdi
movl -0x2c(%rbp), %esi
movq -0x20(%rbp), %rdx
sarq $0x4, %rdx
movl -0x24(%rbp), %ecx
subl $0x4, %ecx
callq 0x8c20
movl %eax, -0x4(%rbp)
jmp 0x8d5f
movl -0x2c(%rbp), %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ComplexNetworks-DCC-FCUP[P]fase/DynamicGraph.cpp
// Function: DynamicGraph::_init()
void DynamicGraph::_init() {
  _num_nodes = _num_edges = 0;

  ready = false;
  _adjM             = NULL;
  _adjOut           = NULL;
  _adjIn            = NULL;
  _neighbours       = NULL;
  hybrid_ch         = NULL;
  _hashM            = NULL;
  _in               = NULL;
  _out              = NULL;
  _hash_out         = NULL;
  _num_neighbours   = NULL;
  _array_neighbours = NULL;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movl $0x0, 0x10(%rax)
movl $0x0, 0xc(%rax)
movb $0x0, 0x78(%rax)
movq $0x0, 0x48(%rax)
movq $0x0, 0x58(%rax)
movq $0x0, 0x60(%rax)
movq $0x0, 0x68(%rax)
movq $0x0, 0x40(%rax)
movq $0x0, 0x70(%rax)
movq $0x0, 0x20(%rax)
movq $0x0, 0x28(%rax)
movq $0x0, 0x30(%rax)
movq $0x0, 0x38(%rax)
movq $0x0, 0x50(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x60, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, 0x48(%rax)
je 0xa940
movl $0x0, -0xc(%rbp)
movq -0x28(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0xc(%rcx), %eax
jge 0xa923
movq -0x28(%rbp), %rax
movq 0x48(%rax), %rax
movslq -0xc(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0xa916
movq -0x28(%rbp), %rax
movq 0x48(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0xa914
movq -0x30(%rbp), %rdi
callq 0x32f0
jmp 0xa916
jmp 0xa918
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xa8d2
movq -0x28(%rbp), %rax
movq 0x48(%rax), %rax
movq %rax, -0x38(%rbp)
cmpq $0x0, %rax
je 0xa93e
movq -0x38(%rbp), %rdi
callq 0x32f0
jmp 0xa940
movq -0x28(%rbp), %rax
cmpq $0x0, 0x70(%rax)
je 0xaa40
movl $0x0, -0xc(%rbp)
movq -0x28(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0xc(%rcx), %eax
jge 0xaa23
movq -0x28(%rbp), %rax
cmpq $0x0, 0x30(%rax)
je 0xa9f0
movl $0x0, -0x10(%rbp)
movq -0x28(%rbp), %rcx
movl -0x10(%rbp), %eax
movq 0x30(%rcx), %rcx
movslq -0xc(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0xa9ee
movq -0x28(%rbp), %rax
movq 0x70(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
je 0xa9e1
movq -0x18(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x40(%rbp)
cmpq $0x0, %rax
je 0xa9df
movq -0x40(%rbp), %rdi
movl $0x10, %esi
callq 0x3220
jmp 0xa9a8
jmp 0xa9e3
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xa978
jmp 0xa9f0
movq -0x28(%rbp), %rax
movq 0x70(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x48(%rbp)
cmpq $0x0, %rax
je 0xaa13
movq -0x48(%rbp), %rdi
callq 0x32f0
jmp 0xaa15
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xa956
movq -0x28(%rbp), %rax
movq 0x70(%rax), %rax
movq %rax, -0x50(%rbp)
cmpq $0x0, %rax
je 0xaa3e
movq -0x50(%rbp), %rdi
callq 0x32f0
jmp 0xaa40
movq -0x28(%rbp), %rax
cmpq $0x0, 0x40(%rax)
je 0xaa68
movq -0x28(%rbp), %rax
movq 0x40(%rax), %rax
movq %rax, -0x58(%rbp)
cmpq $0x0, %rax
je 0xaa66
movq -0x58(%rbp), %rdi
callq 0x32f0
jmp 0xaa68
movq -0x28(%rbp), %rax
movb $0x0, 0x78(%rax)
addq $0x60, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, 0x10(%rax)
movb $0x0, 0x78(%rax)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0xc(%rcx), %eax
jge 0xab48
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rcx
movslq -0xc(%rbp), %rdx
movl $0x0, (%rcx,%rdx,4)
movq 0x28(%rax), %rcx
movslq -0xc(%rbp), %rdx
movl $0x0, (%rcx,%rdx,4)
movq 0x30(%rax), %rcx
movslq -0xc(%rbp), %rdx
movl $0x0, (%rcx,%rdx,4)
movq 0x38(%rax), %rcx
movslq -0xc(%rbp), %rdx
movl $0x0, (%rcx,%rdx,4)
movq 0x60(%rax), %rdi
movslq -0xc(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
callq 0xbe90
movq -0x18(%rbp), %rax
movq 0x58(%rax), %rdi
movslq -0xc(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
callq 0xbe90
movq -0x18(%rbp), %rax
movq 0x68(%rax), %rdi
movslq -0xc(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
callq 0xbe90
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xaaa6
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x18(%rbp)
movq 0x58(%rax), %rdi
movslq -0xc(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
leaq -0x10(%rbp), %rsi
callq 0xc1b0
movq -0x18(%rbp), %rax
movq 0x28(%rax), %rcx
movslq -0xc(%rbp), %rdx
movl (%rcx,%rdx,4), %esi
addl $0x1, %esi
movl %esi, (%rcx,%rdx,4)
movq 0x60(%rax), %rdi
movslq -0x10(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
leaq -0xc(%rbp), %rsi
callq 0xc1b0
movq -0x18(%rbp), %rdi
movq 0x20(%rdi), %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movl 0x10(%rdi), %eax
addl $0x1, %eax
movl %eax, 0x10(%rdi)
movl -0x10(%rbp), %esi
movl -0xc(%rbp), %edx
movq (%rdi), %rax
callq *0x48(%rax)
testb $0x1, %al
jne 0xb6eb
movq -0x18(%rbp), %rax
movq 0x68(%rax), %rdi
movslq -0x10(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
leaq -0xc(%rbp), %rsi
callq 0xc1b0
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rcx
movslq -0x10(%rbp), %rdx
movl (%rcx,%rdx,4), %esi
addl $0x1, %esi
movl %esi, (%rcx,%rdx,4)
movq 0x68(%rax), %rdi
movslq -0xc(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
leaq -0x10(%rbp), %rsi
callq 0xc1b0
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl %edx, -0x10(%rbp)
movq -0x8(%rbp), %rdi
movq %rdi, -0x18(%rbp)
movb $0x0, 0x78(%rdi)
movl -0xc(%rbp), %esi
movl -0x10(%rbp), %edx
movq (%rdi), %rax
callq *0x48(%rax)
testb $0x1, %al
jne 0xb733
jmp 0xb804
movq -0x18(%rbp), %rdi
movq 0x58(%rdi), %rsi
movslq -0xc(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rsi
movl -0x10(%rbp), %edx
callq 0xb810
movq -0x18(%rbp), %rdi
movq 0x28(%rdi), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %edx
addl $-0x1, %edx
movl %edx, (%rax,%rcx,4)
movq 0x60(%rdi), %rsi
movslq -0x10(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rsi
movl -0xc(%rbp), %edx
callq 0xb810
movq -0x18(%rbp), %rdi
movq 0x20(%rdi), %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %edx
addl $-0x1, %edx
movl %edx, (%rax,%rcx,4)
movl 0x10(%rdi), %eax
addl $-0x1, %eax
movl %eax, 0x10(%rdi)
movl -0x10(%rbp), %esi
movl -0xc(%rbp), %edx
movq (%rdi), %rax
callq *0x48(%rax)
testb $0x1, %al
jne 0xb804
movq -0x18(%rbp), %rdi
movq 0x68(%rdi), %rsi
movslq -0xc(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rsi
movl -0x10(%rbp), %edx
callq 0xb810
movq -0x18(%rbp), %rdi
movq 0x38(%rdi), %rax
movslq -0xc(%rbp), %rcx
movl (%rax,%rcx,4), %edx
addl $-0x1, %edx
movl %edx, (%rax,%rcx,4)
movq 0x68(%rdi), %rsi
movslq -0x10(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rsi
movl -0xc(%rbp), %edx
callq 0xb810
movq -0x18(%rbp), %rax
movq 0x38(%rax), %rax
movslq -0x10(%rbp), %rcx
movl (%rax,%rcx,4), %edx
addl $-0x1, %edx
movl %edx, (%rax,%rcx,4)
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl %edx, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x30(%rbp)
testb $0x1, 0x78(%rax)
jne 0xb93d
movl $0x0, -0x1c(%rbp)
movq -0x30(%rbp), %rcx
movl -0x1c(%rbp), %eax
movq 0x28(%rcx), %rcx
movslq -0x14(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0xb934
movq -0x30(%rbp), %rax
movq 0x58(%rax), %rdi
movslq -0x14(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
movslq -0x1c(%rbp), %rsi
callq 0xc130
movl (%rax), %eax
cmpl -0x18(%rbp), %eax
jne 0xb927
movb $0x1, -0x1(%rbp)
jmp 0xba2c
jmp 0xb929
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0xb8e7
movb $0x0, -0x1(%rbp)
jmp 0xba2c
movq -0x30(%rbp), %rax
movq 0x40(%rax), %rax
movslq -0x14(%rbp), %rcx
cmpl $0x0, (%rax,%rcx,4)
jne 0xb970
movq -0x30(%rbp), %rax
movq 0x48(%rax), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x18(%rbp), %rcx
movb (%rax,%rcx), %al
andb $0x1, %al
movb %al, -0x1(%rbp)
jmp 0xba2c
movq -0x30(%rbp), %rax
movq 0x28(%rax), %rax
movslq -0x14(%rbp), %rcx
cmpl $0x3, (%rax,%rcx,4)
jge 0xb9d9
movl $0x0, -0x20(%rbp)
movq -0x30(%rbp), %rcx
movl -0x20(%rbp), %eax
movq 0x28(%rcx), %rcx
movslq -0x14(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0xb9d3
movq -0x30(%rbp), %rax
movq 0x58(%rax), %rdi
movslq -0x14(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
movslq -0x20(%rbp), %rsi
callq 0xc130
movl (%rax), %eax
cmpl -0x18(%rbp), %eax
jne 0xb9c6
movb $0x1, -0x1(%rbp)
jmp 0xba2c
jmp 0xb9c8
movl -0x20(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x20(%rbp)
jmp 0xb989
movb $0x0, -0x1(%rbp)
jmp 0xba2c
movq -0x30(%rbp), %rdx
movq 0x70(%rdx), %rax
movslq -0x14(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movl -0x18(%rbp), %ecx
movq 0x30(%rdx), %rdx
movslq -0x14(%rbp), %rsi
andl (%rdx,%rsi,4), %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, -0x28(%rbp)
je 0xba28
movq -0x28(%rbp), %rax
movl (%rax), %eax
cmpl -0x18(%rbp), %eax
jne 0xba1a
movb $0x1, -0x1(%rbp)
jmp 0xba2c
movq -0x28(%rbp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rbp)
jmp 0xba02
movb $0x0, -0x1(%rbp)
movb -0x1(%rbp), %al
andb $0x1, %al
addq $0x30, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x38(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xc330
movq -0x38(%rbp), %rax
movslq 0xc(%rax), %rax
movl $0x8, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3030
movq %rax, %rcx
movq -0x38(%rbp), %rax
movq %rcx, 0x50(%rax)
movl $0x0, -0xc(%rbp)
movq -0x38(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0xc(%rcx), %eax
jge 0xbcdf
movq -0x38(%rbp), %rax
movq 0x68(%rax), %rdi
movslq -0xc(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
callq 0xc220
movl $0x4, %ecx
mulq %rcx
movq %rax, %rdi
seto %cl
movq $-0x1, %rax
testb $0x1, %cl
cmovneq %rax, %rdi
callq 0x3030
movq %rax, %rsi
movq -0x38(%rbp), %rax
movq 0x50(%rax), %rcx
movslq -0xc(%rbp), %rdx
movq %rsi, (%rcx,%rdx,8)
movq 0x68(%rax), %rdi
movslq -0xc(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
callq 0xbf10
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0x10(%rbp)
movq -0x38(%rbp), %rax
movq 0x68(%rax), %rdi
movslq -0xc(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
callq 0xbf40
movq %rax, -0x28(%rbp)
leaq -0x18(%rbp), %rdi
leaq -0x28(%rbp), %rsi
callq 0xc350
testb $0x1, %al
jne 0xbc7a
jmp 0xbcb9
leaq -0x18(%rbp), %rdi
callq 0xc390
movq %rax, %rcx
movq -0x38(%rbp), %rax
movl (%rcx), %edx
movq 0x50(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movslq -0x10(%rbp), %rcx
movl %edx, (%rax,%rcx,4)
leaq -0x18(%rbp), %rdi
xorl %esi, %esi
callq 0xc3b0
movq %rax, -0x30(%rbp)
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xbc4b
movq -0x38(%rbp), %rax
movq 0x68(%rax), %rdi
movslq -0xc(%rbp), %rax
imulq $0x18, %rax, %rax
addq %rax, %rdi
callq 0xbe90
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xbbc8
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
leaq -0x18(%rbp), %rdi
callq 0xc330
movl $0x0, -0xc(%rbp)
movq -0x20(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0xc(%rcx), %eax
jge 0xbd82
movl $0x0, -0x10(%rbp)
movq -0x20(%rbp), %rcx
movl -0x10(%rbp), %eax
movq 0x38(%rcx), %rcx
movslq -0xc(%rbp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0xbd75
movq -0x20(%rbp), %rax
movq 0x68(%rax), %rdi
movslq -0xc(%rbp), %rcx
imulq $0x18, %rcx, %rcx
addq %rcx, %rdi
movq 0x50(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rsi
movslq -0x10(%rbp), %rax
shlq $0x2, %rax
addq %rax, %rsi
callq 0xc1b0
movl -0x10(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x10(%rbp)
jmp 0xbd27
jmp 0xbd77
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xbd14
movq -0x20(%rbp), %rax
cmpq $0x0, 0x50(%rax)
je 0xbe02
movl $0x0, -0xc(%rbp)
movq -0x20(%rbp), %rcx
movl -0xc(%rbp), %eax
cmpl 0xc(%rcx), %eax
jge 0xbde5
movq -0x20(%rbp), %rax
movq 0x50(%rax), %rax
movslq -0xc(%rbp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0xbdd8
movq -0x20(%rbp), %rax
movq 0x50(%rax), %rax
movslq -0xc(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
cmpq $0x0, %rax
je 0xbdd6
movq -0x28(%rbp), %rdi
callq 0x32f0
jmp 0xbdd8
jmp 0xbdda
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0xbd94
movq -0x20(%rbp), %rax
movq 0x50(%rax), %rax
movq %rax, -0x30(%rbp)
cmpq $0x0, %rax
je 0xbe00
movq -0x30(%rbp), %rdi
callq 0x32f0
jmp 0xbe02
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movq %rdi, -0x8(%rbp)
movsd 0xfb4(%rip), %xmm0      # 0x19098
movsd %xmm0, 0xafd4(%rip)     # 0x230c0
movl $0x0, -0xc(%rbp)
movl -0xc(%rbp), %eax
cmpl 0xaf14(%rip), %eax      # 0x23010
jge 0x18129
movslq -0xc(%rbp), %rcx
leaq 0xaf17(%rip), %rax      # 0x23020
movsd (%rax,%rcx,8), %xmm0
mulsd 0xafaa(%rip), %xmm0     # 0x230c0
movsd %xmm0, 0xafa2(%rip)     # 0x230c0
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
jmp 0x180f3
testb $0x1, 0xaf9b(%rip)      # 0x230cb
je 0x1816b
movsd 0xaf86(%rip), %xmm0     # 0x230c0
movaps 0x11cf(%rip), %xmm1     # 0x19310
pand %xmm1, %xmm0
movsd 0x11b3(%rip), %xmm1     # 0x19300
ucomisd %xmm1, %xmm0
jbe 0x1816b
movq -0x8(%rbp), %rdi
movl 0xaeb3(%rip), %esi      # 0x23010
leaq 0xaebc(%rip), %rdx      # 0x23020
callq 0x39f0
jmp 0x1817b
movsd 0xf25(%rip), %xmm0      # 0x19098
movsd %xmm0, 0xaf45(%rip)     # 0x230c0
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x30, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x17a70
movl -0x8(%rbp), %edi
movq -0x10(%rbp), %rsi
callq 0x17ac0
cmpl $0x2, 0xa8f2(%rip)      # 0x23010
jle 0x18729
cmpl $0x14, 0xa8e9(%rip)     # 0x23010
jl 0x18752
movq 0x98a8(%rip), %rax      # 0x21fd8
movq (%rax), %rdi
leaq 0x13cb(%rip), %rsi      # 0x19b05
movl $0x13, %edx
movb $0x0, %al
callq 0x3310
movl $0x1, -0x4(%rbp)
jmp 0x187ef
xorl %eax, %eax
movl %eax, %edi
callq 0x31d0
movl %eax, %edi
callq 0x11ca0
movl $0x3c8, %edi            # imm = 0x3C8
callq 0x3210
movq %rax, %rdi
movq %rdi, %rax
movq %rax, -0x30(%rbp)
movq 0xa88b(%rip), %rsi      # 0x23008
movzbl 0xa944(%rip), %edx      # 0x230c8
andl $0x1, %edx
callq 0x3760
jmp 0x1878e
movq -0x30(%rbp), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdi
callq 0x180d0
callq 0xa1f0
movq -0x18(%rbp), %rdi
movl 0xa862(%rip), %esi      # 0x23010
callq 0x3a50
callq 0xa210
movq -0x18(%rbp), %rdi
callq 0x18190
movq -0x18(%rbp), %rdi
callq 0x18690
movl $0x0, -0x4(%rbp)
jmp 0x187ef
movq -0x30(%rbp), %rdi
movq %rax, %rcx
movl %edx, %eax
movq %rcx, -0x20(%rbp)
movl %eax, -0x24(%rbp)
movl $0x3c8, %esi            # imm = 0x3C8
callq 0x3220
jmp 0x187f8
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
movq -0x20(%rbp), %rdi
callq 0x3380
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
subq $0xb0, %rsp
movb $0x0, -0x1(%rbp)
leaq -0x88(%rbp), %rax
movq %rax, -0xa8(%rbp)
movl $0x0, -0x9c(%rbp)
movl -0x9c(%rbp), %eax
cmpq $0x10, %rax
jae 0x1459
movq -0xa8(%rbp), %rax
movl -0x9c(%rbp), %ecx
movq $0x0, (%rax,%rcx,8)
movl -0x9c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x9c(%rbp)
jmp 0x1427
jmp 0x145b
movl 0x2c6f(%rip), %eax      # 0x40d0
movl $0x40, %ecx
cltd
idivl %ecx
movl %edx, %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
movq %rax, %rcx
movl 0x2c52(%rip), %eax      # 0x40d0
movl $0x40, %esi
cltd
idivl %esi
cltq
orq -0x88(%rbp,%rax,8), %rcx
movq %rcx, -0x88(%rbp,%rax,8)
movq $0x0, -0x98(%rbp)
movslq 0x2c1e(%rip), %rax      # 0x40c8
movq %rax, -0x90(%rbp)
movl 0x2c19(%rip), %edi      # 0x40d0
addl $0x1, %edi
leaq -0x88(%rbp), %rsi
xorl %eax, %eax
movl %eax, %ecx
leaq -0x98(%rbp), %r8
movq %rcx, %rdx
callq 0x1100
cmpl $0x0, %eax
je 0x14ed
movl 0x2bf1(%rip), %edi      # 0x40d0
leaq -0x1(%rbp), %rsi
movl $0x1, %edx
callq 0x10c0
movb -0x1(%rbp), %al
addq $0xb0, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movb %dil, %al
movb %al, -0x5(%rbp)
movsbl -0x5(%rbp), %eax
cmpl $0x30, %eax
jl 0x1558
movsbl -0x5(%rbp), %eax
cmpl $0x39, %eax
jg 0x1558
movsbl -0x5(%rbp), %eax
subl $0x30, %eax
movl %eax, -0x4(%rbp)
jmp 0x15a1
movsbl -0x5(%rbp), %eax
cmpl $0x61, %eax
jl 0x1579
movsbl -0x5(%rbp), %eax
cmpl $0x66, %eax
jg 0x1579
movsbl -0x5(%rbp), %eax
subl $0x61, %eax
addl $0xa, %eax
movl %eax, -0x4(%rbp)
jmp 0x15a1
movsbl -0x5(%rbp), %eax
cmpl $0x41, %eax
jl 0x159a
movsbl -0x5(%rbp), %eax
cmpl $0x46, %eax
jg 0x159a
movsbl -0x5(%rbp), %eax
subl $0x46, %eax
addl $0xa, %eax
movl %eax, -0x4(%rbp)
jmp 0x15a1
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lua.c
// Function: main
int main (int argc, char **argv) {
  int status;
  struct Smain s;
  lua_State *L = lua_open();  /* create state */
  if (L == NULL) {
    l_message(argv[0], "cannot create state: not enough memory");
    return EXIT_FAILURE;
  }
  s.argc = argc;
  s.argv = argv;
  status = lua_cpcall(L, &pmain, &s);
  report(L, status);
  lua_close(L);
  return (status || s.status) ? EXIT_FAILURE : EXIT_SUCCESS;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl $0x0, -0x4(%rbp)
movl %edi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
callq 0x1bf30
movq %rax, -0x38(%rbp)
cmpq $0x0, -0x38(%rbp)
jne 0x56c2
movq -0x10(%rbp), %rax
movq (%rax), %rdi
leaq 0x25950(%rip), %rsi     # 0x2b004
callq 0x5730
movl $0x1, -0x4(%rbp)
jmp 0x5724
movl -0x8(%rbp), %eax
movl %eax, -0x30(%rbp)
movq -0x10(%rbp), %rax
movq %rax, -0x28(%rbp)
movq -0x38(%rbp), %rdi
leaq 0xc5(%rip), %rsi        # 0x57a0
leaq -0x30(%rbp), %rdx
callq 0x8820
movl %eax, -0x14(%rbp)
movq -0x38(%rbp), %rdi
movl -0x14(%rbp), %esi
callq 0x5970
movq -0x38(%rbp), %rdi
callq 0x13e80
movb $0x1, %al
cmpl $0x0, -0x14(%rbp)
movb %al, -0x39(%rbp)
jne 0x5711
cmpl $0x0, -0x20(%rbp)
setne %al
movb %al, -0x39(%rbp)
movb -0x39(%rbp), %dl
xorl %eax, %eax
movl $0x1, %ecx
testb $0x1, %dl
cmovnel %ecx, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x40, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lua.c
// Function: report
static int report (lua_State *L, int status) {
  if (status && !lua_isnil(L, -1)) {
    const char *msg = lua_tostring(L, -1);
    if (msg == NULL) msg = "(error object is not a string)";
    l_message(progname, msg);
    lua_pop(L, 1);
  }
  return status;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
cmpl $0x0, -0xc(%rbp)
je 0x59de
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
callq 0x6fe0
cmpl $0x0, %eax
je 0x59de
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x74a0
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x59c0
leaq 0x25891(%rip), %rax     # 0x2b24d
movq %rax, -0x18(%rbp)
movq 0x31909(%rip), %rdi     # 0x372d0
movq -0x18(%rbp), %rsi
callq 0x5730
movq -0x8(%rbp), %rdi
movl $0xfffffffe, %esi       # imm = 0xFFFFFFFE
callq 0x6ab0
movl -0xc(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lua.c
// Function: handle_luainit
static int handle_luainit (lua_State *L) {
  const char *init = getenv(LUA_INIT);
  if (init == NULL) return 0;  /* status OK */
  else if (init[0] == '@')
    return dofile(L, init+1);
  else
    return dostring(L, init, "=" LUA_INIT);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movq %rdi, -0x10(%rbp)
leaq 0x25632(%rip), %rdi     # 0x2b035
callq 0x5030
movq %rax, -0x18(%rbp)
cmpq $0x0, -0x18(%rbp)
jne 0x5a1c
movl $0x0, -0x4(%rbp)
jmp 0x5a55
movq -0x18(%rbp), %rax
movsbl (%rax), %eax
cmpl $0x40, %eax
jne 0x5a3e
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
addq $0x1, %rsi
callq 0x6010
movl %eax, -0x4(%rbp)
jmp 0x5a55
movq -0x10(%rbp), %rdi
movq -0x18(%rbp), %rsi
leaq 0x255e7(%rip), %rdx     # 0x2b034
callq 0x6070
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lua.c
// Function: print_usage
static void print_usage (void) {
  fprintf(stderr,
  "usage: %s [options] [script [args]].\n"
  "Available options are:\n"
  "  -e stat  execute string " LUA_QL("stat") "\n"
  "  -l name  require library " LUA_QL("name") "\n"
  "  -i       enter interactive mode after executing " LUA_QL("script") "\n"
  "  -v       show version information\n"
  "  --       stop handling options\n"
  "  -        execute stdin and stop handling options\n"
  ,
  progname);
  fflush(stderr);
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq 0x313bd(%rip), %rax     # 0x36ff8
movq (%rax), %rdi
movq 0x3168b(%rip), %rdx     # 0x372d0
leaq 0x2540f(%rip), %rsi     # 0x2b05b
movb $0x0, %al
callq 0x52d0
movq 0x3139e(%rip), %rax     # 0x36ff8
movq (%rax), %rdi
callq 0x5360
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/gplessis[P]dotdeb-redis/deps/lua/src/lua.c
// Function: dotty
static void dotty (lua_State *L) {
  int status;
  const char *oldprogname = progname;
  progname = NULL;
  while ((status = loadline(L)) != -1) {
    if (status == 0) status = docall(L, 0, 0);
    report(L, status);
    if (status == 0 && lua_gettop(L) > 0) {  /* any result to print? */
      lua_getglobal(L, "print");
      lua_insert(L, 1);
      if (lua_pcall(L, lua_gettop(L)-1, 0, 0) != 0)
        l_message(progname, lua_pushfstring(L,
                               "error calling " LUA_QL("print") " (%s)",
                               lua_tostring(L, -1)));
    }
  }
  lua_settop(L, 0);  /* clear stack */
  fputs("\n", stdout);
  fflush(stdout);
  progname = oldprogname;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq 0x313fd(%rip), %rax     # 0x372d0
movq %rax, -0x18(%rbp)
movq $0x0, 0x313ee(%rip) # 0x372d0
movq -0x8(%rbp), %rdi
callq 0x6470
movl %eax, -0xc(%rbp)
cmpl $-0x1, %eax
je 0x5fcd
cmpl $0x0, -0xc(%rbp)
jne 0x5f0d
movq -0x8(%rbp), %rdi
xorl %edx, %edx
movl %edx, %esi
callq 0x6100
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rdi
movl -0xc(%rbp), %esi
callq 0x5970
cmpl $0x0, -0xc(%rbp)
jne 0x5fc8
movq -0x8(%rbp), %rdi
callq 0x6a80
cmpl $0x0, %eax
jle 0x5fc8
movq -0x8(%rbp), %rdi
movl $0xffffd8ee, %esi       # imm = 0xFFFFD8EE
leaq 0x252b9(%rip), %rdx     # 0x2b1fe
callq 0x7d90
movq -0x8(%rbp), %rdi
movl $0x1, %esi
callq 0x6d40
movq -0x8(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x8(%rbp), %rdi
callq 0x6a80
movq -0x20(%rbp), %rdi
movl %eax, %esi
subl $0x1, %esi
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x8700
cmpl $0x0, %eax
je 0x5fc6
movq 0x31349(%rip), %rax     # 0x372d0
movq %rax, -0x28(%rbp)
movq -0x8(%rbp), %rax
movq %rax, -0x30(%rbp)
movq -0x8(%rbp), %rdi
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
xorl %eax, %eax
movl %eax, %edx
callq 0x74a0
movq -0x30(%rbp), %rdi
movq %rax, %rdx
leaq 0x25251(%rip), %rsi     # 0x2b204
movb $0x0, %al
callq 0x7a10
movq -0x28(%rbp), %rdi
movq %rax, %rsi
callq 0x5730
jmp 0x5fc8
jmp 0x5ee2
movq -0x8(%rbp), %rdi
xorl %esi, %esi
callq 0x6ab0
movq 0x30ff1(%rip), %rax     # 0x36fd0
movq (%rax), %rsi
leaq 0x2605b(%rip), %rdi     # 0x2c044
callq 0x51b0
movq 0x30fdb(%rip), %rax     # 0x36fd0
movq (%rax), %rdi
callq 0x5360
movq -0x18(%rbp), %rax
movq %rax, 0x312c8(%rip)     # 0x372d0
addq $0x30, %rsp
popq %rbp
retq
nop