LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/lh3[P]bgt/kexpr.c
// Function: ke_set_real_func1
int ke_set_real_func1(kexpr_t *ke, const char *name, double (*func)(double))
{
	int i, n = 0;
	for (i = 0; i < ke->n; ++i) {
		ke1_t *e = &ke->e[i];
		if (e->ttype == KET_FUNC && e->n_args == 1 && strcmp(e->name, name) == 0)
			e->f.real_func1 = func, e->user_func = KEF_REAL, ++n;
	}
	return n;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
movl (%rdi), %r15d
testl %r15d, %r15d
jle 0x1d487
movq %rdi, %rbp
xorl %r12d, %r12d
movabsq $-0xffffff0001, %rcx    # imm = 0xFFFFFF000000FFFF
movabsq $0x10000000003, %rdx    # imm = 0x10000000003
xorl %r14d, %r14d
movl $0x0, 0x4(%rsp)
movq 0x8(%rbp), %r13
movq (%r13,%r12), %rbx
movq %rbx, %rax
andq %rcx, %rax
cmpq %rdx, %rax
jne 0x1d476
movq 0x8(%r13,%r12), %rdi
movq 0x10(%rsp), %rsi
callq 0x2230
testl %eax, %eax
jne 0x1d462
movq 0x8(%rsp), %rax
movq %rax, 0x10(%r13,%r12)
movabsq $0x1ff07ff0003, %rax    # imm = 0x1FF07FF0003
andq %rax, %rbx
orq $0x8000000, %rbx        # imm = 0x8000000
movq %rbx, (%r13,%r12)
incl 0x4(%rsp)
movl (%rbp), %r15d
movabsq $-0xffffff0001, %rcx    # imm = 0xFFFFFF000000FFFF
movabsq $0x10000000003, %rdx    # imm = 0x10000000003
incq %r14
movslq %r15d, %rax
addq $0x30, %r12
cmpq %rax, %r14
jl 0x1d410
jmp 0x1d48f
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/lh3[P]bgt/kexpr.c
// Function: ke_set_real_func2
int ke_set_real_func2(kexpr_t *ke, const char *name, double (*func)(double, double))
{
	int i, n = 0;
	for (i = 0; i < ke->n; ++i) {
		ke1_t *e = &ke->e[i];
		if (e->ttype == KET_FUNC && e->n_args == 2 && strcmp(e->name, name) == 0)
			e->f.real_func2 = func, e->user_func = KEF_REAL, ++n;
	}
	return n;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
movl (%rdi), %r15d
testl %r15d, %r15d
jle 0x1d562
movq %rdi, %rbp
xorl %r12d, %r12d
movabsq $-0xffffff0001, %rcx    # imm = 0xFFFFFF000000FFFF
movabsq $0x20000000003, %rdx    # imm = 0x20000000003
xorl %r14d, %r14d
movl $0x0, 0x4(%rsp)
movq 0x8(%rbp), %r13
movq (%r13,%r12), %rbx
movq %rbx, %rax
andq %rcx, %rax
cmpq %rdx, %rax
jne 0x1d551
movq 0x8(%r13,%r12), %rdi
movq 0x10(%rsp), %rsi
callq 0x2230
testl %eax, %eax
jne 0x1d53d
movq 0x8(%rsp), %rax
movq %rax, 0x10(%r13,%r12)
movabsq $0x2ff07ff0003, %rax    # imm = 0x2FF07FF0003
andq %rax, %rbx
orq $0x8000000, %rbx        # imm = 0x8000000
movq %rbx, (%r13,%r12)
incl 0x4(%rsp)
movl (%rbp), %r15d
movabsq $-0xffffff0001, %rcx    # imm = 0xFFFFFF000000FFFF
movabsq $0x20000000003, %rdx    # imm = 0x20000000003
incq %r14
movslq %r15d, %rax
addq $0x30, %r12
cmpq %rax, %r14
jl 0x1d4eb
jmp 0x1d56a
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/lh3[P]bgt/kexpr.c
// Function: ke_set_default_func
int ke_set_default_func(kexpr_t *ke)
{
	int n = 0;
	n += ke_set_real_func1(ke, "exp", exp);
	n += ke_set_real_func1(ke, "log", log);
	n += ke_set_real_func1(ke, "log10", log10);
	n += ke_set_real_func1(ke, "sqrt", sqrt);
	n += ke_set_real_func1(ke, "sin", sin);
	n += ke_set_real_func1(ke, "cos", cos);
	n += ke_set_real_func1(ke, "tan", tan);
	n += ke_set_real_func2(ke, "pow", pow);
	return n;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
leaq 0x2902(%rip), %rsi      # 0x1fe90
movq 0x8a5b(%rip), %rdx      # 0x25ff0
callq 0x1d3c7
movl %eax, %ebp
leaq 0x28f1(%rip), %rsi      # 0x1fe94
movq 0x89f6(%rip), %rdx      # 0x25fa0
movq %rbx, %rdi
callq 0x1d3c7
movl %eax, %r14d
addl %ebp, %r14d
leaq 0x28d9(%rip), %rsi      # 0x1fe98
movq 0x89f2(%rip), %rdx      # 0x25fb8
movq %rbx, %rdi
callq 0x1d3c7
movl %eax, %r15d
leaq 0x28c6(%rip), %rsi      # 0x1fe9e
movq 0x8a01(%rip), %rdx      # 0x25fe0
movq %rbx, %rdi
callq 0x1d3c7
movl %eax, %ebp
addl %r15d, %ebp
addl %r14d, %ebp
leaq 0x28ad(%rip), %rsi      # 0x1fea3
movq 0x89d3(%rip), %rdx      # 0x25fd0
movq %rbx, %rdi
callq 0x1d3c7
movl %eax, %r14d
leaq 0x2898(%rip), %rsi      # 0x1fea7
movq 0x8992(%rip), %rdx      # 0x25fa8
movq %rbx, %rdi
callq 0x1d3c7
movl %eax, %r15d
addl %r14d, %r15d
leaq 0x2880(%rip), %rsi      # 0x1feab
movq 0x8996(%rip), %rdx      # 0x25fc8
movq %rbx, %rdi
callq 0x1d3c7
movl %eax, %r14d
addl %r15d, %r14d
addl %ebp, %r14d
leaq 0x2865(%rip), %rsi      # 0x1feaf
movq 0x893f(%rip), %rdx      # 0x25f90
movq %rbx, %rdi
callq 0x1d4a2
addl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/lh3[P]bgt/kexpr.c
// Function: ke_unset
void ke_unset(kexpr_t *ke)
{
	int i;
	for (i = 0; i < ke->n; ++i) {
		ke1_t *e = &ke->e[i];
		if (e->ttype == KET_VAL && e->name) e->assigned = 0;
	}
}

// Assembly:
movl (%rdi), %eax
testl %eax, %eax
jle 0x1d6a4
xorl %ecx, %ecx
xorl %edx, %edx
movq 0x8(%rdi), %rsi
movq (%rsi,%rcx), %r8
cmpw $0x1, %r8w
jne 0x1d695
cmpq $0x0, 0x8(%rsi,%rcx)
je 0x1d695
andq $-0x400ffff, %r8        # imm = 0xFBFF0001
movq %r8, (%rsi,%rcx)
movl (%rdi), %eax
incq %rdx
movslq %eax, %rsi
addq $0x30, %rcx
cmpq %rsi, %rdx
jl 0x1d671
retq
// File: /workspace/github_c_makefile_star2_O3/lh3[P]bgt/kexpr.c
// Function: ke_print
void ke_print(const kexpr_t *ke)
{
	int i;
	if (ke == 0) return;
	for (i = 0; i < ke->n; ++i) {
		const ke1_t *u = &ke->e[i];
		if (i) putchar(' ');
		if (u->ttype == KET_VAL) {
			if (u->name) printf("%s", u->name);
			else if (u->vtype == KEV_REAL) printf("%g", u->r);
			else if (u->vtype == KEV_INT) printf("%lld", (long long)u->i);
			else if (u->vtype == KEV_STR) printf("\"%s\"", u->s);
		} else if (u->ttype == KET_OP) {
			printf("%s", ke_opstr[u->op]);
		} else if (u->ttype == KET_FUNC) {
			printf("%s(%d)", u->name, u->n_args);
		}
	}
	putchar('\n');
}

// Assembly:
testq %rdi, %rdi
je 0x1d7b6
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
cmpl $0x0, (%rdi)
jle 0x1d79e
leaq 0x26cc(%rip), %r12      # 0x1fd98
leaq 0x27e0(%rip), %r15      # 0x1feb3
xorl %r13d, %r13d
xorl %ebp, %ebp
movq 0x8(%rbx), %r14
testq %r13, %r13
je 0x1d6eb
movl $0x20, %edi
callq 0x2060
movq (%r14,%r13), %rdx
cmpw $0x3, %dx
je 0x1d756
movzwl %dx, %eax
cmpl $0x2, %eax
je 0x1d73b
cmpl $0x1, %eax
jne 0x1d76d
movq 0x8(%r14,%r13), %rsi
testq %rsi, %rsi
jne 0x1d74a
shrl $0x10, %edx
andl $0x3ff, %edx            # imm = 0x3FF
cmpl $0x3, %edx
je 0x1d790
cmpl $0x2, %edx
je 0x1d782
cmpl $0x1, %edx
jne 0x1d76d
movsd 0x18(%r14,%r13), %xmm0
leaq 0x19e2(%rip), %rdi      # 0x1f114
movb $0x1, %al
callq 0x2190
jmp 0x1d76d
shrq $0x20, %rdx
movsbq %dl, %rax
movslq (%r12,%rax,4), %rsi
addq %r12, %rsi
movq %r15, %rdi
xorl %eax, %eax
callq 0x2190
jmp 0x1d76d
movq 0x8(%r14,%r13), %rsi
sarq $0x28, %rdx
leaq 0x2755(%rip), %rdi      # 0x1febb
xorl %eax, %eax
callq 0x2190
incq %rbp
movslq (%rbx), %rax
addq $0x30, %r13
cmpq %rax, %rbp
jl 0x1d6d8
jmp 0x1d79e
movq 0x20(%r14,%r13), %rsi
leaq 0x1981(%rip), %rdi      # 0x1f10f
jmp 0x1d74d
movq 0x28(%r14,%r13), %rsi
leaq 0x271a(%rip), %rdi      # 0x1feb6
jmp 0x1d74d
movl $0xa, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2060
retq
// File: /workspace/github_c_makefile_star2_O3/ComplexNetworks-DCC-FCUP[P]fase/Fase.cpp
// Function: Fase::Fase(Graph*, bool)
Fase::Fase(Graph* _g, bool _directed)
{
  directed = _directed;
  graph = _g;
  sampling = false;

  vext = new int*[MAXMOTIF];
  for (int i = 1; i < MAXMOTIF; i++)
    vext[i] = new int[graph->numNodes()];

  vextSz = new int[MAXMOTIF];
  vsub = new int[MAXMOTIF];
  sampProb = new double[MAXMOTIF];

  Label::init(_g, _directed);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r14
leaq 0x18(%rdi), %rbx
movq %rbx, %rdi
callq 0x46c8
leaq 0x58(%r14), %rax
movl $0x0, 0x58(%r14)
xorl %ecx, %ecx
movq %rcx, 0x60(%r14)
movq %rax, 0x68(%r14)
movq %rax, 0x70(%r14)
movq %rcx, 0x78(%r14)
movb %bpl, (%r14)
movq %r15, 0x8(%r14)
movb $0x0, 0x1(%r14)
movl $0xa0, %edi
callq 0x2030
movq %rax, 0x80(%r14)
movl $0x1, %r12d
movq 0x8(%r14), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
movq $-0x1, %rdi
testl %eax, %eax
js 0x28b4
movl %eax, %edi
shlq $0x2, %rdi
callq 0x2030
movq 0x80(%r14), %rcx
movq %rax, (%rcx,%r12,8)
incq %r12
cmpq $0x14, %r12
jne 0x2899
movl $0x50, %edi
callq 0x2030
movq %rax, 0x88(%r14)
movl $0x50, %edi
callq 0x2030
movq %rax, 0x90(%r14)
movl $0xa0, %edi
callq 0x2030
movq %rax, 0x98(%r14)
movzbl %bpl, %esi
movq %r15, %rdi
callq 0x44a8
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
jmp 0x2917
movq %rax, %r15
addq $0x50, %r14
movq %r14, %rdi
callq 0x3232
movq %rbx, %rdi
callq 0x46d8
movq %r15, %rdi
callq 0x22c0
// File: /workspace/github_c_makefile_star2_O3/ComplexNetworks-DCC-FCUP[P]fase/Fase.cpp
// Function: Fase::~Fase()
Fase::~Fase()
{
  for (int i = 1; i < MAXMOTIF; i++)
    delete[] vext[i];
  delete[] vext;
  delete[] vextSz;
  delete[] vsub;
  delete[] sampProb;

  igtrie.destroy();
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl $0x1, %r14d
movq 0x80(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x2958
callq 0x2220
incq %r14
cmpq $0x14, %r14
jne 0x2943
movq 0x80(%rbx), %rdi
testq %rdi, %rdi
je 0x2972
callq 0x2220
movq 0x88(%rbx), %rdi
testq %rdi, %rdi
je 0x2983
callq 0x2220
movq 0x90(%rbx), %rdi
testq %rdi, %rdi
je 0x2994
callq 0x2220
movq 0x98(%rbx), %rdi
testq %rdi, %rdi
je 0x29a5
callq 0x2220
leaq 0x18(%rbx), %r14
movq %r14, %rdi
callq 0x46fa
addq $0x50, %rbx
movq %rbx, %rdi
callq 0x3232
movq %r14, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x46d8
movq %rax, %rdi
callq 0x314d
// File: /workspace/github_c_makefile_star2_O3/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:
testl %esi, %esi
jle 0x29f5
movq 0x98(%rdi), %rax
movl %esi, %ecx
xorl %esi, %esi
movsd (%rdx,%rsi,8), %xmm0
movsd %xmm0, (%rax,%rsi,8)
incq %rsi
cmpq %rsi, %rcx
jne 0x29e3
movb $0x1, 0x1(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
movl %esi, 0x10(%rdi)
movl $0x0, 0x14(%rdi)
addq $0x18, %rdi
callq 0x4758
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
testl %eax, %eax
jle 0x2ad7
xorl %r14d, %r14d
cmpb $0x1, 0x1(%rbx)
jne 0x2a44
movq 0x98(%rbx), %rax
movsd (%rax), %xmm0
callq 0x7a3c
testb %al, %al
je 0x2ac1
movq 0x90(%rbx), %rax
movl %r14d, (%rax)
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
movl %r14d, %esi
callq *0xa8(%rax)
movq %rax, %r15
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
movl %r14d, %esi
callq *0x68(%rax)
movq 0x88(%rbx), %rcx
movl $0x0, 0x4(%rcx)
testl %eax, %eax
jle 0x2ab0
movq 0x80(%rbx), %rdx
movl %eax, %eax
xorl %esi, %esi
movl (%r15,%rsi,4), %edi
cmpl %r14d, %edi
jle 0x2aa8
movq 0x8(%rdx), %r8
movslq 0x4(%rcx), %r9
leal 0x1(%r9), %r10d
movl %r10d, 0x4(%rcx)
movl %edi, (%r8,%r9,4)
incq %rsi
cmpq %rsi, %rax
jne 0x2a8b
movq %rbx, %rdi
movl $0x1, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x2ade
incl %r14d
movq 0x8(%rbx), %rdi
movq (%rdi), %rax
callq *0x38(%rax)
cmpl %eax, %r14d
jl 0x2a2a
popq %rbx
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rcx, %r12
movl %edx, 0x4(%rsp)
movq %rsi, %rdx
movq %rdi, %r14
leaq 0xa0(%rdi), %r13
movl 0x10(%rdi), %esi
movq %r13, %rdi
callq 0x4588
leaq 0x231(%r14), %r15
movb $0x0, 0x231(%r14)
leaq 0x38(%rsp), %rbx
movq %rbx, -0x10(%rbx)
movq %r13, %rdi
callq 0x20b0
leaq (%r14,%rax), %rdx
addq $0xa0, %rdx
leaq 0x28(%rsp), %rbp
movq %rbp, %rdi
movq %r13, %rsi
callq 0x3340
movq %r12, %rdi
movq %rbp, %rsi
movq %r15, %rdx
callq 0x4c84
movq 0x28(%rsp), %rdi
cmpq %rbx, %rdi
je 0x2e41
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x21a0
leaq 0x18(%rsp), %r12
movq %r12, -0x10(%r12)
movq %r15, %rdi
callq 0x20b0
leaq (%rax,%r15), %rdx
leaq 0x8(%rsp), %rdi
movq %r15, %rsi
callq 0x3340
addq $0x50, %r14
leaq 0x8(%rsp), %rsi
movq %r14, %rdi
callq 0x3158
movl 0x4(%rsp), %ecx
addl %ecx, (%rax)
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x2e92
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq %rax, %r14
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x2ed4
movq 0x18(%rsp), %rsi
jmp 0x2ecc
movq %rax, %r14
jmp 0x2ed4
movq %rax, %r14
movq 0x28(%rsp), %rdi
cmpq %rbx, %rdi
je 0x2ed4
movq 0x38(%rsp), %rsi
incq %rsi
callq 0x21a0
movq %r14, %rdi
callq 0x22c0
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rsi, %r14
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x2edc
xorps %xmm0, %xmm0
movups %xmm0, (%rbx)
movq $0x0, 0x10(%rbx)
movq 0x68(%r14), %r15
addq $0x58, %r14
cmpq %r14, %r15
je 0x30df
leaq 0x18(%rsp), %r12
leaq 0x48(%rsp), %r13
leaq 0x30(%rsp), %rbp
movq %r12, 0x8(%rsp)
movq 0x20(%r15), %rsi
movq 0x28(%r15), %rdx
addq %rsi, %rdx
leaq 0x8(%rsp), %rdi
callq 0x32aa
movl 0x40(%r15), %eax
movl %eax, 0x28(%rsp)
movl %eax, 0x30(%rsp)
movq %r13, 0x38(%rsp)
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
addq %rsi, %rdx
leaq 0x38(%rsp), %rdi
callq 0x32aa
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x372c
movq 0x38(%rsp), %rdi
cmpq %r13, %rdi
je 0x3068
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x21a0
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x307f
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
movq %r15, %rdi
callq 0x20e0
movq %rax, %r15
cmpq %r14, %rax
jne 0x3004
movq (%rbx), %r14
movq 0x8(%rbx), %r15
cmpq %r15, %r14
je 0x30e2
movq %r15, %rax
subq %r14, %rax
sarq $0x3, %rax
movabsq $-0x3333333333333333, %rcx # imm = 0xCCCCCCCCCCCCCCCD
imulq %rax, %rcx
bsrq %rcx, %rdx
xorl $0x3f, %edx
addl %edx, %edx
xorq $0x7e, %rdx
movq %r14, %rdi
movq %r15, %rsi
callq 0x39f9
movq %r14, %rdi
movq %r15, %rsi
callq 0x3ad6
movq (%rbx), %r14
jmp 0x30e2
xorl %r14d, %r14d
movq 0x8(%rbx), %rsi
movq %r14, %rdi
callq 0x4459
movq %rbx, %rax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
jmp 0x3102
movq %rax, %r14
jmp 0x313d
movq %rax, %r14
jmp 0x3126
movq %rax, %r14
movq 0x38(%rsp), %rdi
cmpq %r13, %rdi
je 0x3126
movq 0x48(%rsp), %rsi
incq %rsi
callq 0x21a0
movq 0x8(%rsp), %rdi
cmpq %r12, %rdi
je 0x313d
movq 0x18(%rsp), %rsi
incq %rsi
callq 0x21a0
movq %rbx, %rdi
callq 0x31d4
movq %r14, %rdi
callq 0x22c0
// File: /workspace/github_c_makefile_star2_O3/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
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
cmpb $0x0, 0xedc9(%rip)      # 0x13298
je 0x4530
testl %edx, %edx
jle 0x4566
movl %edx, %r13d
addq %r13, %r13
xorl %r12d, %r12d
xorl %r15d, %r15d
movq 0xeda4(%rip), %rdi      # 0x13290
movl (%r14,%r12,2), %esi
movq (%rdi), %rax
movl %ebx, %edx
callq *0x48(%rax)
movzbl %al, %ebp
movl %r12d, %ecx
shlq %cl, %rbp
movq 0xed88(%rip), %rdi      # 0x13290
movl (%r14,%r12,2), %edx
movq (%rdi), %rax
movl %ebx, %esi
callq *0x48(%rax)
movzbl %al, %eax
leal 0x1(%r12), %ecx
shlq %cl, %rax
orq %rbp, %rax
orq %rax, %r15
addq $0x2, %r12
cmpq %r12, %r13
jne 0x44e5
jmp 0x4569
testl %edx, %edx
jle 0x4566
movl %edx, %r13d
xorl %r12d, %r12d
xorl %r15d, %r15d
movq 0xed4c(%rip), %rdi      # 0x13290
movl (%r14,%r12,4), %esi
movq (%rdi), %rax
movl %ebx, %edx
callq *0x50(%rax)
movzbl %al, %eax
movl %r12d, %ecx
shlq %cl, %rax
orq %rax, %r15
incq %r12
cmpq %r12, %r13
jne 0x453d
jmp 0x4569
xorl %r15d, %r15d
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/ComplexNetworks-DCC-FCUP[P]fase/Label.cpp
// Function: Label::fillNautyMatrix(char*, int, long long)
void Label::fillNautyMatrix(char* sadjM, int K, long long int mask)
{
  int i, j;
  for (i = 0; i < K * K; i++)
    sadjM[i] = '0';
  sadjM[K * K] = '\0';

  int acc = 0;
  for (i = K - 1; i >= 1; i--)
  {
    int gone = 0;
    for (j = 0; j < i; j++)
    {
      if (directed)
      {
        sadjM[j * K + i] =
          ((mask & (1LL << (2 * j + acc))) > 0) ? '1' : '0';
        sadjM[i * K + j] =
          ((mask & (1LL << ((2 * j + 1) + acc))) > 0) ? '1' : '0';
        gone += 2;
      }
      else
      {
        sadjM[i * K + j] = sadjM[j * K + i] =
          ((mask & (1LL << (j + acc))) > 0) ? '1' : '0';
        gone++;
      }
    }

    acc += gone;
  }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, %r15
movl %esi, %r12d
imull %r12d, %r12d
testl %esi, %esi
je 0x46b2
movq %rdx, %rbx
movl %esi, %r14d
cmpq $0x1, %r12
movq %r12, %rdx
adcq $0x0, %rdx
movq %r15, %rdi
movl $0x30, %esi
callq 0x20d0
movb $0x0, (%r15,%r12)
cmpl $0x2, %r14d
jl 0x46b7
movl %r14d, %esi
decl %r14d
leaq -0x1(%rsi), %rdi
imulq %rsi, %rdi
addq %r15, %rdi
movq %rsi, %rax
negq %rax
movq %rax, 0x8(%rsp)
leaq (%r15,%rsi), %r9
decq %r9
xorl %r11d, %r11d
movq %rsi, %r10
leaq -0x1(%r10), %rax
movq %rax, 0x10(%rsp)
movl %r11d, %r12d
movq %r12, %rax
movq %r12, %rdx
movq %r9, %r13
movq %rdi, %rbp
xorl %r8d, %r8d
xorl %r11d, %r11d
cmpb $0x1, 0xec75(%rip)      # 0x13298
jne 0x465a
movl $0x1, %r15d
movl %eax, %ecx
shlq %cl, %r15
testq %rbx, %r15
setg %cl
orb $0x30, %cl
movb %cl, (%r13)
leal 0x1(%rax), %ecx
movl $0x1, %r15d
shlq %cl, %r15
testq %rbx, %r15
setg %cl
orb $0x30, %cl
movl $0x2, %r15d
jmp 0x4678
movl $0x1, %r15d
movl %edx, %ecx
shlq %cl, %r15
testq %rbx, %r15
setg %cl
orb $0x30, %cl
movb %cl, (%r13)
movl $0x1, %r15d
addl %r15d, %r11d
movb %cl, (%rbp)
incq %r8
incq %rbp
addq %rsi, %r13
incq %rdx
addq $0x2, %rax
cmpq %r8, %r14
jne 0x461c
addl %r12d, %r11d
decq %r14
addq 0x8(%rsp), %rdi
decq %r9
cmpq $0x2, %r10
movq 0x10(%rsp), %r10
jg 0x45fe
jmp 0x46b7
movb $0x0, (%r15,%r12)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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:
movl 0x4(%rdi), %eax
testl %eax, %eax
je 0x4756
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
jle 0x472d
xorl %r14d, %r14d
movq 0x8(%rbx), %rcx
movq (%rcx,%r14,8), %rdi
testq %rdi, %rdi
je 0x4722
callq 0x2220
movl 0x4(%rbx), %eax
incq %r14
movslq %eax, %rcx
cmpq %rcx, %r14
jl 0x470d
movq 0x8(%rbx), %rdi
callq 0x21e0
movq 0x10(%rbx), %rdi
callq 0x21e0
movq 0x18(%rbx), %rdi
callq 0x21e0
movq $0x0, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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
movq %rdx, %r14
movl %esi, %eax
movq %rdi, %r15
movq 0x8(%rdi), %rbx
movslq %eax, %rbp
movq (%rbx,%rbp,8), %rax
movl %r14d, %r13d
andl $0xf, %r13d
movl %r13d, %edx
movl (%rax,%rdx,4), %eax
cmpl $-0x1, %eax
je 0x4873
movq 0x10(%r15), %r8
jmp 0x48fb
movl %ecx, 0x4(%rsp)
movl 0x4(%r15), %r12d
cmpl (%r15), %r12d
jne 0x4890
movq %r15, %rdi
callq 0x47e6
movl 0x4(%r15), %r12d
movq 0x8(%r15), %rbx
leal 0x1(%r12), %eax
movl %eax, 0x4(%r15)
movl $0x40, %edi
callq 0x2030
movslq %r12d, %rdx
movq %rax, (%rbx,%rdx,8)
movq 0x8(%r15), %rax
movq (%rax,%rdx,8), %rax
pcmpeqd %xmm0, %xmm0
movdqu %xmm0, 0x30(%rax)
movdqu %xmm0, 0x20(%rax)
movdqu %xmm0, 0x10(%rax)
movdqu %xmm0, (%rax)
movq 0x8(%r15), %rbx
movq (%rbx,%rbp,8), %rax
movl %edx, (%rax,%r13,4)
movl 0x4(%rsp), %ecx
cmpl $0x5, %ecx
movl $0x0, %esi
cmovll %ecx, %esi
movq 0x10(%r15), %r8
movl %esi, (%r8,%rdx,4)
movq 0x18(%r15), %rsi
movl $0x0, (%rsi,%rdx,4)
movl (%rax,%r13,4), %eax
movslq %eax, %rdx
cmpl $0x0, (%r8,%rdx,4)
jne 0x4911
sarq $0x4, %r14
addl $-0x4, %ecx
jmp 0x4851
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4a11
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 0x4a06
movl %ebp, %eax
movl %r12d, %ecx
shll %cl, %eax
movq 0x10(%rbx), %rcx
movl (%rcx,%rsi,4), %ecx
cltq
testl %ecx, %ecx
je 0x49eb
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 0x4a01
orq %r13, %rax
movq %rbx, %rdi
movq %r14, %rdx
movq %rax, %rcx
movl 0x8(%rsp), %r8d
movq 0x10(%rsp), %r9
callq 0x4966
incq %rbp
cmpq $0x10, %rbp
jne 0x49a4
jmp 0x4a4e
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 0x4a3d
movups 0x18(%rsp), %xmm0
movups %xmm0, (%rsi)
addq $0x10, 0x28(%rbx)
jmp 0x4a4e
addq $0x20, %rbx
leaq 0x18(%rsp), %rdx
movq %rbx, %rdi
callq 0x4af2
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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), %eax
leaq 0x83ae(%rip), %r15      # 0xd050
testl %eax, %eax
jle 0x4d41
leaq 0x4c80(%r14), %rcx
xorl %edx, %edx
movslq 0x4b08(%r14), %r8
movq %rdx, %rdi
imulq %r8, %rdi
leaq (%rcx,%rdi,4), %rdi
movq %rdi, 0x4c78(%r14)
leaq (%rdi,%r8,4), %r8
addq $-0x4, %r8
cmpq %rdi, %r8
jb 0x4cf0
movl $0x0, (%r8)
addq $-0x4, %r8
cmpq %rdi, %r8
jae 0x4cd9
movl 0x4b04(%r14), %eax
testl %eax, %eax
jle 0x4d32
movq (%rsi), %r8
xorl %r9d, %r9d
movl %edx, %r10d
imull %eax, %r10d
movslq %r10d, %r10
addq %r8, %r10
cmpb $0x31, (%r9,%r10)
jne 0x4d2a
movl %r9d, %eax
andl $0x1f, %eax
movl (%r15,%rax,4), %eax
movl %r9d, %r10d
shrl $0x5, %r10d
orl %eax, (%rdi,%r10,4)
movl 0x4b04(%r14), %eax
incq %r9
cmpl %eax, %r9d
jl 0x4cfa
incq %rdx
movslq %eax, %rdi
cmpq %rdi, %rdx
jl 0x4cb3
leaq 0x4c80(%r14), %rdi
leaq 0x4b0c(%r14), %rsi
leaq 0x4b84(%r14), %rdx
leaq 0x4bfc(%r14), %r8
leaq 0x4(%r14), %r10
movl 0x4b08(%r14), %r11d
movq %fs:0x0, %rcx
leaq -0x80(%rcx), %r13
leaq 0xe529(%rip), %rbp      # 0x132a8
leaq 0xe432(%rip), %r9       # 0x131b8
xorl %r12d, %r12d
xorl %ecx, %ecx
pushq %r13
pushq %rax
pushq %r11
pushq $0x12c0                 # imm = 0x12C0
pushq %r10
pushq %rbp
callq 0x7a74
addq $0x30, %rsp
movl 0x4b04(%r14), %ecx
testl %ecx, %ecx
jle 0x4e1a
xorl %eax, %eax
movslq 0x4b08(%r14), %rdx
imulq %rax, %rdx
leaq (,%rdx,4), %rdx
addq %r13, %rdx
movq %rdx, 0x4c78(%r14)
testl %ecx, %ecx
jle 0x4e0c
movslq %r12d, %rdx
addq %rbx, %rdx
xorl %esi, %esi
movq 0x4c78(%r14), %rcx
movl %esi, %edi
shrl $0x5, %edi
movl %esi, %r8d
andl $0x1f, %r8d
movl (%r15,%r8,4), %r8d
testl %r8d, (%rcx,%rdi,4)
sete %cl
xorb $0x31, %cl
movb %cl, (%rdx,%rsi)
movl 0x4b04(%r14), %ecx
incq %rsi
cmpl %ecx, %esi
jl 0x4dd7
addl %esi, %r12d
incq %rax
movslq %ecx, %rdx
cmpq %rdx, %rax
jl 0x4dae
movslq %r12d, %r12
movb $0x0, (%rbx,%r12)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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
movq 0x48(%rdi), %rdi
testq %rdi, %rdi
je 0x51b2
movl 0xc(%rbx), %eax
testl %eax, %eax
jle 0x51ad
xorl %r14d, %r14d
movq 0x48(%rbx), %rcx
movq (%rcx,%r14,8), %rdi
testq %rdi, %rdi
je 0x5199
callq 0x2220
movl 0xc(%rbx), %eax
incq %r14
movslq %eax, %rcx
cmpq %rcx, %r14
jl 0x5184
movq 0x48(%rbx), %rdi
testq %rdi, %rdi
je 0x51b2
callq 0x2220
movq 0x70(%rbx), %rdi
testq %rdi, %rdi
je 0x523a
cmpl $0x0, 0xc(%rbx)
jle 0x5235
xorl %r14d, %r14d
movq 0x30(%rbx), %rax
testq %rax, %rax
je 0x520e
cmpl $0x0, (%rax,%r14,4)
jle 0x520e
xorl %r15d, %r15d
movq 0x70(%rbx), %rcx
movq (%rcx,%r14,8), %rcx
movq (%rcx,%r15,8), %rdi
testq %rdi, %rdi
je 0x5202
movq 0x8(%rdi), %r12
movl $0x10, %esi
callq 0x21a0
movq %r12, %rdi
testq %r12, %r12
jne 0x51e8
movq 0x30(%rbx), %rax
incq %r15
movslq (%rax,%r14,4), %rcx
cmpq %rcx, %r15
jl 0x51d7
movq 0x70(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x5220
callq 0x2220
incq %r14
movslq 0xc(%rbx), %rax
cmpq %rax, %r14
jl 0x51c4
movq 0x70(%rbx), %rdi
testq %rdi, %rdi
je 0x523a
callq 0x2220
movq 0x40(%rbx), %rdi
testq %rdi, %rdi
je 0x5248
callq 0x2220
movb $0x0, 0x78(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x52e7
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 0x52b4
movq %r15, (%r8,%r11,4)
movq -0x8(%r9,%r11,4), %r15
cmpq %r15, (%r9,%r11,4)
je 0x52c3
movq %r15, (%r9,%r11,4)
movq -0x8(%r10,%r11,4), %r15
cmpq %r15, (%r10,%r11,4)
je 0x52d2
movq %r15, (%r10,%r11,4)
incq %r14
movslq 0xc(%rdi), %r15
addq $0x6, %r11
cmpq %r15, %r14
jl 0x5295
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x4ee2
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 0x531c
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, %r13
movq %r14, (%rax)
addq $0x8, %r13
testl %ebp, %ebp
je 0x53e7
leaq (%r14,%r14,2), %rax
leaq -0x18(,%rax,8), %rax
movabsq $-0x5555555555555555, %rcx # imm = 0xAAAAAAAAAAAAAAAB
mulq %rcx
shrq $0x4, %rdx
leaq (%rdx,%rdx,2), %rax
leaq 0x18(,%rax,8), %r12
movq %r13, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x20d0
movq %r13, 0x60(%rbx)
movq %r15, %rdi
callq 0x2030
movq %rax, %r13
movq %r14, (%rax)
addq $0x8, %r13
movq %r13, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x20d0
movq %r13, 0x58(%rbx)
movq %r15, %rdi
callq 0x2030
movq %rax, %r15
movq %r14, (%rax)
addq $0x8, %r15
movq %r15, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x20d0
jmp 0x5410
movq %r13, 0x60(%rbx)
movq %r15, %rdi
callq 0x2030
movq %r14, (%rax)
addq $0x8, %rax
movq %rax, 0x58(%rbx)
movq %r15, %rdi
callq 0x2030
movq %rax, %r15
movq %r14, (%rax)
addq $0x8, %r15
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_O3/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
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %esi, %ebp
movq %rdi, %rbx
movl %esi, 0xc(%rsp)
movl %edx, 0x8(%rsp)
movq 0x58(%rdi), %rax
movslq %esi, %r14
leaq (%r14,%r14,2), %rcx
leaq (%rax,%rcx,8), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x5904
movl %edx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi)
jmp 0x590e
leaq 0x8(%rsp), %rdx
callq 0x6800
movq 0x28(%rbx), %rax
incl (%rax,%r14,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 0x593d
movl %ebp, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi)
jmp 0x5947
leaq 0xc(%rsp), %rdx
callq 0x6800
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 0x59f1
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 0x599a
movl 0xc(%rsp), %ecx
movl %ecx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi)
jmp 0x59a8
leaq 0xc(%rsp), %rdx
callq 0x6800
movq 0x68(%rbx), %rax
movq 0x38(%rbx), %rcx
movslq 0x8(%rsp), %rdx
incl (%rcx,%rdx,4)
movslq 0xc(%rsp), %rdx
leaq (%rdx,%rdx,2), %rdx
leaq (%rax,%rdx,8), %rdi
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x59db
movl 0x8(%rsp), %eax
movl %eax, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi)
jmp 0x59e9
leaq 0x8(%rsp), %rdx
callq 0x6800
movq 0x38(%rbx), %rcx
movslq 0xc(%rsp), %rax
incl (%rcx,%rax,4)
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x5ab2
movslq %ebp, %r12
leaq (%r12,%r12,2), %r15
shlq $0x3, %r15
movq 0x58(%rbx), %rsi
addq %r15, %rsi
movl %r14d, %edx
callq 0x5ac2
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 0x5ac2
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 0x5ab2
addq 0x68(%rbx), %r15
movq %r15, %rsi
movl %r14d, %edx
callq 0x5ac2
movq 0x38(%rbx), %rax
movq (%rsp), %rcx
decl (%rax,%rcx,4)
addq 0x68(%rbx), %r12
movq %r12, %rsi
movl %ebp, %edx
callq 0x5ac2
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_O3/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, %rax
cmpb $0x0, 0x78(%rdi)
je 0x5b77
movq 0x40(%rdi), %rcx
cmpl $0x0, (%rcx,%rax,4)
je 0x5bab
movq 0x28(%rdi), %rcx
movslq (%rcx,%rax,4), %rcx
cmpq $0x2, %rcx
jg 0x5bba
testl %ecx, %ecx
jle 0x5be8
movq 0x58(%rdi), %rsi
leaq (%rax,%rax,2), %rax
movq (%rsi,%rax,8), %rsi
decq %rcx
xorl %edi, %edi
cmpl %edx, (%rsi,%rdi,4)
sete %al
je 0x5b76
leaq 0x1(%rdi), %r8
cmpq %rdi, %rcx
movq %r8, %rdi
jne 0x5b62
retq
movq 0x28(%rdi), %rcx
movslq (%rcx,%rax,4), %rcx
testq %rcx, %rcx
jle 0x5be8
movq 0x58(%rdi), %rsi
leaq (%rax,%rax,2), %rax
movq (%rsi,%rax,8), %rsi
decq %rcx
xorl %edi, %edi
cmpl %edx, (%rsi,%rdi,4)
sete %al
je 0x5b76
leaq 0x1(%rdi), %r8
cmpq %rdi, %rcx
movq %r8, %rdi
jne 0x5b95
jmp 0x5b76
movq 0x48(%rdi), %rcx
movq (%rcx,%rax,8), %rax
movslq %edx, %rcx
movb (%rax,%rcx), %al
retq
movq 0x30(%rdi), %rcx
movq 0x70(%rdi), %rsi
movq (%rsi,%rax,8), %rsi
movl (%rcx,%rax,4), %eax
andl %edx, %eax
cltq
movq (%rsi,%rax,8), %rcx
testq %rcx, %rcx
je 0x5be8
cmpl %edx, (%rcx)
sete %al
je 0x5b76
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
jne 0x5bd6
jmp 0x5b76
xorl %eax, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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), %r15
leaq (,%r15,8), %rdi
testq %r15, %r15
movq $-0x1, %r14
cmovsq %r14, %rdi
callq 0x2030
movq %rax, 0x50(%rbx)
testq %r15, %r15
jle 0x5d5a
movq 0x68(%rbx), %rax
xorl %r15d, %r15d
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 0x5d4e
addq %rax, %r12
movq 0x50(%rbx), %rsi
movq (%rsi,%r15,8), %rsi
xorl %edi, %edi
leaq (%rcx,%rdi), %r8
addq $0x4, %r8
movl -0x4(%r8), %r9d
movl %r9d, (%rsi,%rdi)
addq $0x4, %rdi
cmpq %rdx, %r8
jne 0x5d2b
cmpq %rdx, %rcx
je 0x5d4e
movq %rcx, 0x8(%r12)
incq %r15
movslq 0xc(%rbx), %rcx
cmpq %rcx, %r15
jl 0x5ce6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl 0xc(%rdi), %ecx
testl %ecx, %ecx
jle 0x5de3
movq 0x38(%rbx), %rax
xorl %r14d, %r14d
cmpl $0x0, (%rax,%r14,4)
jle 0x5dd8
leaq (%r14,%r14,2), %r15
xorl %r12d, %r12d
xorl %r13d, %r13d
movq 0x50(%rbx), %rcx
movq 0x68(%rbx), %rdx
leaq (%rdx,%r15,8), %rdi
movq (%rcx,%r14,8), %rdx
addq %r12, %rdx
movq 0x8(%rdi), %rsi
cmpq 0x10(%rdi), %rsi
je 0x5dbc
movl (%rdx), %ecx
movl %ecx, (%rsi)
addq $0x4, %rsi
movq %rsi, 0x8(%rdi)
jmp 0x5dc5
callq 0x6800
movq 0x38(%rbx), %rax
incq %r13
movslq (%rax,%r14,4), %rcx
addq $0x4, %r12
cmpq %rcx, %r13
jl 0x5d91
movl 0xc(%rbx), %ecx
incq %r14
movslq %ecx, %rdx
cmpq %rdx, %r14
jl 0x5d80
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x5e2a
testl %ecx, %ecx
jle 0x5e1c
xorl %r14d, %r14d
movq 0x50(%rbx), %rax
movq (%rax,%r14,8), %rdi
testq %rdi, %rdi
je 0x5e08
callq 0x2220
movl 0xc(%rbx), %ecx
incq %r14
movslq %ecx, %rax
cmpq %rax, %r14
jl 0x5df3
movq 0x50(%rbx), %rdi
testq %rdi, %rdi
je 0x5e2a
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x2220
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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, 0x70ca(%rip)      # 0x13640
movslq 0x7013(%rip), %rsi      # 0x13590
testq %rsi, %rsi
jle 0xc5b4
leaq (,%rsi,8), %rcx
movsd 0x182e(%rip), %xmm0     # 0xddc0
xorl %edx, %edx
leaq 0x7005(%rip), %r8       # 0x135a0
mulsd (%rdx,%r8), %xmm0
addq $0x8, %rdx
cmpq %rdx, %rcx
jne 0xc59b
movsd %xmm0, 0x708e(%rip)     # 0x13640
jmp 0xc5bc
movsd 0x1804(%rip), %xmm0     # 0xddc0
cmpb $0x1, 0x7088(%rip)      # 0x1364b
jne 0xc5e3
andpd 0x1793(%rip), %xmm0     # 0xdd60
ucomisd 0x17f3(%rip), %xmm0     # 0xddc8
jbe 0xc5e3
leaq 0x6fc2(%rip), %rdx      # 0x135a0
jmp 0x29d4
movq %rax, 0x7056(%rip)      # 0x13640
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1675(%rip), %rdi      # 0xe0c9
callq 0x2270
xorl %edi, %edi
callq 0x2150
movq %rax, 0x6d89(%rip)      # 0x137f0
movl %ebp, %edi
movq %rbx, %rsi
callq 0xc045
movl 0x6b19(%rip), %eax      # 0x13590
addl $-0x14, %eax
cmpl $-0x12, %eax
jbe 0xcae9
xorl %ebx, %ebx
xorl %edi, %edi
callq 0x2150
movl %eax, %edi
callq 0x7a04
movl $0x3c8, %edi            # imm = 0x3C8
callq 0x2190
movq %rax, %r14
movq 0x6ae5(%rip), %rsi      # 0x13588
movzbl 0x6b9e(%rip), %edx      # 0x13648
movq %rax, %rdi
callq 0x283c
movq %r14, %rdi
callq 0xc565
callq 0x4e30
movl 0x6acb(%rip), %esi      # 0x13590
movq %r14, %rdi
callq 0x29fa
callq 0x4e3e
movq %r14, %rdi
callq 0xc5eb
movq %r14, %rdi
callq 0xca07
movl %ebx, %eax
popq %rbx
popq %r14
popq %rbp
retq
callq 0x25cf
movl $0x1, %ebx
jmp 0xcae2
movq %rax, %rbx
movl $0x3c8, %esi            # imm = 0x3C8
movq %r14, %rdi
callq 0x21a0
movq %rbx, %rdi
callq 0x22c0
// File: /workspace/github_c_makefile_star2_O3/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 0x5(%rsp), %rbx
movq %rax, 0x2(%rbx)
movabsq $0x7974742f7665642f, %rax # imm = 0x7974742F7665642F
movq %rax, -0x5(%rbx)
movl $0xd, %r13d
leaq 0xcba(%rip), %r14       # 0x2032
movq %rsp, %r15
leaq 0xcba(%rip), %r12       # 0x203c
movabsq $0x30414d41797474, %rbp # imm = 0x30414D41797474
leal -0x1(%r13), %ecx
cmpl $0xa, %ecx
jl 0x13a6
leal -0xb(%r13), %ecx
movl $0x8, %esi
movq %rbx, %rdi
movq %r14, %rdx
jmp 0x13b5
testl %ecx, %ecx
js 0x13df
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, 0x2d0b(%rip)      # 0x40dc
testl %eax, %eax
jns 0x13e6
decl %r13d
jns 0x138c
jmp 0x1466
movq %rbp, 0x5(%rsp)
jmp 0x13bc
leaq 0xc59(%rip), %rdi       # 0x2046
movq %rsp, %rsi
xorl %eax, %eax
callq 0x10a0
movl 0x2cdf(%rip), %edi      # 0x40dc
leaq 0x2cdc(%rip), %rsi      # 0x40e0
callq 0x1120
movaps 0xc00(%rip), %xmm0      # 0x2010
leaq 0x10(%rsp), %rbx
movaps %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 0x2c93(%rip), %edi      # 0x40dc
xorl %esi, %esi
callq 0x1090
movl 0x2c86(%rip), %edi      # 0x40dc
xorl %esi, %esi
movq %rbx, %rdx
callq 0x1130
movl 0x2c76(%rip), %eax      # 0x40dc
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq