LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/poset_pathCover.c
// Function: getWeightsOfPath
static double* getWeightsOfPath(struct Graph* poset, int* path, int databaseSize) {
	double* weights = malloc(path[0] * sizeof(double));

	weights[0] = (double)path[0];
	for (int i=1; i<path[0]; ++i) {
		weights[i] = ((struct Graph*)poset->vertices[path[i]]->label)->activity / (double)databaseSize;
	}
	return weights;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, %ebp
movq %rsi, %rbx
movq %rdi, %r14
movslq (%rsi), %r15
leaq (,%r15,8), %rdi
callq 0x1180
cvtsi2sd %r15d, %xmm0
movsd %xmm0, (%rax)
cvtsi2sd %ebp, %xmm0
pushq $0x1
popq %rcx
cmpq %r15, %rcx
jge 0x15f82
movq 0x10(%r14), %rdx
movslq (%rbx,%rcx,4), %rsi
movq (%rdx,%rsi,8), %rdx
movq (%rdx), %rdx
cvtsi2sdl 0xc(%rdx), %xmm1
divsd %xmm0, %xmm1
movsd %xmm1, (%rax,%rcx,8)
incq %rcx
jmp 0x15f5b
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/poset_pathCover.c
// Function: dfsDownwardEmbeddingForLocalEasy
struct IntSet* dfsDownwardEmbeddingForLocalEasy(struct Graph* g, struct EvaluationPlan p, int sampleSize, struct GraphPool* gp, struct ShallowGraphPool* sgp) {

	struct SpanningtreeTree spTree = getSampledSpanningtreeTree(getBlockTreeT(g, sgp), sampleSize, 1, gp, sgp);

	int nEvaluations = 0;
	cleanEvaluationPlan(p);
	for (int i=1; i<p.poset->n; ++i) {
		nEvaluations += dfsRaySearchLE(&spTree, p, p.poset->vertices[i], gp);
	}

	dumpSpanningtreeTree(spTree, gp);

	fprintf(stderr, "%i\n", nEvaluations);
	return patternPosetInfoToFeatureSet(p);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movq %rcx, %r15
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %rsi
leaq 0xd0(%rsp), %r12
leaq 0x78(%rsp), %r14
movq %r14, %rdi
movq %rcx, %rdx
callq 0xbe98
movq 0x20(%r14), %rax
movq %rax, 0x20(%rsp)
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0x40(%rsp), %r14
pushq $0x1
popq %rdx
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rcx
movq %r15, %r8
callq 0xc605
movaps (%r12), %xmm0
movaps 0x10(%r12), %xmm1
movaps 0x20(%r12), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x1206c
xorl %ebp, %ebp
pushq $0x1
popq %r15
movq (%r12), %rax
movslq (%rax), %rcx
cmpq %rcx, %r15
jge 0x16061
movq 0x10(%rax), %rax
movq (%rax,%r15,8), %rsi
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups 0x20(%r12), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %r14, %rdi
movq %rbx, %rdx
callq 0x160de
addl %eax, %ebp
incq %r15
jmp 0x1601c
movq 0x70(%rsp), %rax
movq %rax, 0x30(%rsp)
movups 0x40(%rsp), %xmm0
movups 0x50(%rsp), %xmm1
movups 0x60(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0xca2f
movq 0x13f61(%rip), %rax     # 0x29ff8
movq (%rax), %rdi
leaq 0x6f95(%rip), %rsi      # 0x1d036
movl %ebp, %edx
xorl %eax, %eax
callq 0x1150
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups 0x20(%r12), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x121ee
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/poset_pathCover.c
// Function: dfsRaySearchLE
static int dfsRaySearchLE(struct SpanningtreeTree* spTree, struct EvaluationPlan p, struct Vertex* currentPattern, struct GraphPool* gp) {
	int nEvaluations = 0;
	if (!embeddingValueKnown(currentPattern)) {
		struct Graph* pattern = (struct Graph*)(currentPattern->label);
		char match = subtreeCheckForSpanningtreeTree(spTree, pattern, gp);
		wipeCharacteristicsForLocalEasy(*spTree);
		++nEvaluations;
		if (match) {
			for (struct VertexList* e=currentPattern->neighborhood; e!=NULL; e=e->next) {
				nEvaluations += dfsRaySearchLE(spTree, p, e->endPoint, gp);
			}
			updateEvaluationPlan(p, currentPattern->number, 1);
		} else {
			updateEvaluationPlan(p, currentPattern->number, 0);
		}
	}
	return nEvaluations;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r15
movq %rsi, %rdi
callq 0x1209e
xorl %ebp, %ebp
testl %eax, %eax
jne 0x161bf
leaq 0x70(%rsp), %r12
movq (%rbx), %rsi
movq %r15, %rdi
movq %r14, %rdx
callq 0xcfbf
movl %eax, %ebp
movq 0x30(%r15), %rax
movq %rax, 0x30(%rsp)
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups 0x20(%r15), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0xc9af
testb %bpl, %bpl
je 0x16190
pushq $0x1
popq %rbp
movq %rbx, %r13
movq 0x8(%r13), %r13
testq %r13, %r13
je 0x1618c
movq 0x18(%r13), %rsi
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups 0x20(%r12), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %r15, %rdi
movq %r14, %rdx
callq 0x160de
addl %eax, %ebp
jmp 0x16151
movb $0x1, %al
jmp 0x16195
pushq $0x1
popq %rbp
xorl %eax, %eax
movl 0x18(%rbx), %edi
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups 0x20(%r12), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movzbl %al, %esi
callq 0x120b2
movl %ebp, %eax
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/poset_pathCover.c
// Function: latticePathEmbeddingForLocalEasy
struct IntSet* latticePathEmbeddingForLocalEasy(struct Graph* g, struct EvaluationPlan p, int sampleSize, struct GraphPool* gp, struct ShallowGraphPool* sgp) {

	struct SpanningtreeTree spTree = getSampledSpanningtreeTree(getBlockTreeT(g, sgp), sampleSize, 1, gp, sgp);

	int nEvaluations = 0;
	cleanEvaluationPlan(p);
	for (int i=1; i<p.poset->n; ++i) {
		if (!embeddingValueKnown(p.poset->vertices[i])) {
			int* path = getPathInDAG(p.poset->vertices[i]);
			nEvaluations += binarySearchEvaluationLE(&spTree, p, path, gp);
			free(path);
		}
	}

	dumpSpanningtreeTree(spTree, gp);

	fprintf(stderr, "%i\n", nEvaluations);
	return patternPosetInfoToFeatureSet(p);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rcx, %r15
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %rsi
leaq 0xd0(%rsp), %r12
leaq 0x70(%rsp), %r14
movq %r14, %rdi
movq %rcx, %rdx
callq 0xbe98
movq 0x20(%r14), %rax
movq %rax, 0x20(%rsp)
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0x38(%rsp), %r14
pushq $0x1
popq %rdx
movq %r14, %rdi
movl %ebp, %esi
movq %rbx, %rcx
movq %r15, %r8
callq 0xc605
movaps (%r12), %xmm0
movaps 0x10(%r12), %xmm1
movaps 0x20(%r12), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x1206c
xorl %ebp, %ebp
pushq $0x1
popq %r13
movq (%r12), %rax
movslq (%rax), %rcx
cmpq %rcx, %r13
jge 0x162ce
movq 0x10(%rax), %rax
movq (%rax,%r13,8), %rdi
callq 0x1209e
testl %eax, %eax
jne 0x162c9
movq (%r12), %rax
movq 0x10(%rax), %rax
movq (%rax,%r13,8), %rdi
callq 0x15959
movq %rax, %r15
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups 0x20(%r12), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %r14, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x1634d
addl %eax, %ebp
movq %r15, %rdi
callq 0x1030
incq %r13
jmp 0x16261
movq 0x68(%rsp), %rax
movq %rax, 0x30(%rsp)
movups 0x38(%rsp), %xmm0
movups 0x48(%rsp), %xmm1
movups 0x58(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0xca2f
movq 0x13cf4(%rip), %rax     # 0x29ff8
movq (%rax), %rdi
leaq 0x6d28(%rip), %rsi      # 0x1d036
movl %ebp, %edx
xorl %eax, %eax
callq 0x1150
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups 0x20(%r12), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x121ee
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/poset_pathCover.c
// Function: binarySearchEvaluationLE
static int binarySearchEvaluationLE(struct SpanningtreeTree* spTree, struct EvaluationPlan p, int* path, struct GraphPool* gp) {
	int nEvaluations = 0;
	int minIdx = 1;
	int maxIdx = path[0] - 1;

	while (minIdx <= maxIdx) {
		int currentIdx = (minIdx + maxIdx) / 2;
		char match;
		if (!embeddingValueKnown(p.poset->vertices[path[currentIdx]])) {
			struct Graph* pattern = (struct Graph*)(p.poset->vertices[path[currentIdx]]->label);
			match = subtreeCheckForSpanningtreeTree(spTree, pattern, gp);
			wipeCharacteristicsForLocalEasy(*spTree);
			++nEvaluations;
			updateEvaluationPlan(p, path[currentIdx], match);
		} else {
			match = getMatch(p.poset->vertices[path[currentIdx]]);
		}

		if (match) {
			minIdx = currentIdx + 1;
		} else {
			maxIdx = currentIdx - 1;
		}
	}

	return nEvaluations;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x58, %rsp
movq %rdx, 0x50(%rsp)
movq %rsi, %r14
movq %rdi, 0x48(%rsp)
leaq 0x90(%rsp), %r12
movl (%rsi), %r13d
decl %r13d
movl $0x0, 0x3c(%rsp)
pushq $0x1
popq %rbp
movq %rsi, 0x40(%rsp)
cmpl %r13d, %ebp
jg 0x1645d
leal (%rbp,%r13), %ebx
shrl %ebx
movq (%r12), %rax
movq 0x10(%rax), %rax
movslq (%r14,%rbx,4), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1209e
movq (%r12), %rcx
movq 0x10(%rcx), %rcx
movslq (%r14,%rbx,4), %rdx
movq (%rcx,%rdx,8), %rdi
testl %eax, %eax
je 0x163c9
callq 0x120a8
movl %eax, %r15d
jmp 0x16440
movq (%rdi), %rsi
movq 0x48(%rsp), %r14
movq %r14, %rdi
movq 0x50(%rsp), %rdx
callq 0xcfbf
movl %eax, %r15d
movq 0x30(%r14), %rax
movq %rax, 0x30(%rsp)
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movq 0x40(%rsp), %r14
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0xc9af
incl 0x3c(%rsp)
movl (%r14,%rbx,4), %edi
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups 0x20(%r12), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movsbl %r15b, %esi
callq 0x120b2
testb %r15b, %r15b
je 0x1644b
incl %ebx
movl %ebx, %ebp
jmp 0x16450
decl %ebx
movl %ebx, %r13d
leaq 0x90(%rsp), %r12
jmp 0x16386
movl 0x3c(%rsp), %eax
addq $0x58, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/poset_pathCover.c
// Function: latticeLongestPathEmbeddingForLocalEasy
struct IntSet* latticeLongestPathEmbeddingForLocalEasy(struct Graph* g, struct EvaluationPlan p, int sampleSize, struct GraphPool* gp, struct ShallowGraphPool* sgp) {

	struct SpanningtreeTree spTree = getSampledSpanningtreeTree(getBlockTreeT(g, sgp), sampleSize, 1, gp, sgp);

	int nEvaluations = 0;
	cleanEvaluationPlan(p);
	for (int i=1; i<p.poset->n; ++i) {
		if (!embeddingValueKnown(p.poset->vertices[i])) {
			int* path = getLongestPathInDAG(p.poset->vertices[i], p.poset, sgp);
			nEvaluations += binarySearchEvaluationLE(&spTree, p, path, gp);
			free(path);
		}
	}

	dumpSpanningtreeTree(spTree, gp);

	fprintf(stderr, "%i\n", nEvaluations);
	return patternPosetInfoToFeatureSet(p);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rcx, %r14
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %rsi
leaq 0xd0(%rsp), %r13
leaq 0x70(%rsp), %r15
movq %r15, %rdi
movq %rcx, %rdx
callq 0xbe98
movq 0x20(%r15), %rax
movq %rax, 0x20(%rsp)
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0x38(%rsp), %rdi
pushq $0x1
popq %rdx
movl %ebp, %esi
movq %rbx, %rcx
movq %r14, %r8
callq 0xc605
movaps (%r13), %xmm0
movaps 0x10(%r13), %xmm1
movaps 0x20(%r13), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x1206c
xorl %ebp, %ebp
pushq $0x1
popq %r15
movq (%r13), %rax
movslq (%rax), %rcx
cmpq %rcx, %r15
jge 0x1656c
movq 0x10(%rax), %rax
movq (%rax,%r15,8), %rdi
callq 0x1209e
testl %eax, %eax
jne 0x16567
movq (%r13), %rsi
movq 0x10(%rsi), %rax
movq (%rax,%r15,8), %rdi
movq %r14, %rdx
callq 0x15b8b
movq %rax, %r12
movups (%r13), %xmm0
movups 0x10(%r13), %xmm1
movups 0x20(%r13), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0x38(%rsp), %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0x1634d
addl %eax, %ebp
movq %r12, %rdi
callq 0x1030
incq %r15
jmp 0x164fc
movq 0x68(%rsp), %rax
movq %rax, 0x30(%rsp)
movups 0x38(%rsp), %xmm0
movups 0x48(%rsp), %xmm1
movups 0x58(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0xca2f
movq 0x13a56(%rip), %rax     # 0x29ff8
movq (%rax), %rdi
leaq 0x6a8a(%rip), %rsi      # 0x1d036
movl %ebp, %edx
xorl %eax, %eax
callq 0x1150
movups (%r13), %xmm0
movups 0x10(%r13), %xmm1
movups 0x20(%r13), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x121ee
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/poset_pathCover.c
// Function: staticPathCoverEmbeddingForLocalEasy
struct IntSet* staticPathCoverEmbeddingForLocalEasy(struct Graph* g, struct EvaluationPlan p, int sampleSize, struct GraphPool* gp, struct ShallowGraphPool* sgp) {

	struct SpanningtreeTree spTree = getSampledSpanningtreeTree(getBlockTreeT(g, sgp), sampleSize, 1, gp, sgp);

	int nEvaluations = 0;
	cleanEvaluationPlan(p);
	for (size_t i=0; i<p.sketchSize; ++i) {
		nEvaluations += binarySearchEvaluationLE(&spTree, p, p.shrunkPermutations[i], gp);
	}

	dumpSpanningtreeTree(spTree, gp);

	fprintf(stderr, "%i\n", nEvaluations);
	return patternPosetInfoToFeatureSet(p);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rcx, %r14
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %rsi
leaq 0xd0(%rsp), %r12
leaq 0x70(%rsp), %r15
movq %r15, %rdi
movq %rcx, %rdx
callq 0xbe98
movq 0x20(%r15), %rax
movq %rax, 0x20(%rsp)
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0x38(%rsp), %r15
pushq $0x1
popq %rdx
movq %r15, %rdi
movl %ebp, %esi
movq %rbx, %rcx
movq %r14, %r8
callq 0xc605
movaps (%r12), %xmm0
movaps 0x10(%r12), %xmm1
movaps 0x20(%r12), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x1206c
xorl %r14d, %r14d
xorl %r13d, %r13d
cmpq 0x28(%r12), %r13
jae 0x166bc
movq 0x18(%r12), %rax
movq (%rax,%r13,8), %rsi
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups 0x20(%r12), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %r15, %rdi
movq %rbx, %rdx
callq 0x1634d
addl %eax, %r14d
incq %r13
jmp 0x1667a
movq 0x68(%rsp), %rax
movq %rax, 0x30(%rsp)
movups 0x38(%rsp), %xmm0
movups 0x48(%rsp), %xmm1
movups 0x58(%rsp), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0xca2f
movq 0x13906(%rip), %rax     # 0x29ff8
movq (%rax), %rdi
leaq 0x693a(%rip), %rsi      # 0x1d036
movl %r14d, %edx
xorl %eax, %eax
callq 0x1150
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups 0x20(%r12), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x121ee
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/randomGraphGenerators.c
// Function: generateGaussianNoise
void generateGaussianNoise(double* z0, double* z1, double mu, double sigma) {
	static const double epsilon = DBL_EPSILON;
	static const double two_pi = 2.0*3.14159265358979323846;

	double u1, u2;
	do {
		u1 = rand() * (1.0 / RAND_MAX);
		u2 = rand() * (1.0 / RAND_MAX);
	} while ( u1 <= epsilon );

	*z0 = sqrt(-2.0 * log(u1)) * cos(two_pi * u2) * sigma + mu;
	*z1 = sqrt(-2.0 * log(u1)) * sin(two_pi * u2) * sigma + mu;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movsd %xmm1, 0x18(%rsp)
movsd %xmm0, 0x20(%rsp)
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1240
cvtsi2sd %eax, %xmm0
mulsd 0x7372(%rip), %xmm0     # 0x1de08
movsd %xmm0, (%rsp)
callq 0x1240
movsd (%rsp), %xmm0
movsd 0x7363(%rip), %xmm1     # 0x1de10
ucomisd %xmm0, %xmm1
jae 0x16a85
cvtsi2sd %eax, %xmm1
mulsd 0x7349(%rip), %xmm1     # 0x1de08
movsd %xmm1, 0x8(%rsp)
callq 0x10e0
mulsd 0x7346(%rip), %xmm0     # 0x1de18
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x16ae2
sqrtsd %xmm0, %xmm0
jmp 0x16ae7
callq 0x1220
movsd %xmm0, 0x10(%rsp)
movsd 0x8(%rsp), %xmm0
mulsd 0x7325(%rip), %xmm0     # 0x1de20
movsd %xmm0, 0x8(%rsp)
callq 0x10f0
mulsd 0x10(%rsp), %xmm0
mulsd 0x18(%rsp), %xmm0
addsd 0x20(%rsp), %xmm0
movsd %xmm0, (%r14)
movsd (%rsp), %xmm0
callq 0x10e0
mulsd 0x72e9(%rip), %xmm0     # 0x1de18
ucomisd 0x72f1(%rip), %xmm0     # 0x1de28
jb 0x16b3f
sqrtsd %xmm0, %xmm0
jmp 0x16b44
callq 0x1220
movsd %xmm0, (%rsp)
movsd 0x8(%rsp), %xmm0
callq 0x11e0
mulsd (%rsp), %xmm0
mulsd 0x18(%rsp), %xmm0
addsd 0x20(%rsp), %xmm0
movsd %xmm0, (%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/randomGraphGenerators.c
// Function: generateIntegerGaussianNoise
void generateIntegerGaussianNoise(int* z0, int* z1, double sigma) {
	static const double epsilon = DBL_EPSILON;
	static const double two_pi = 2.0*3.14159265358979323846;

	double u1, u2;
	do {
		u1 = rand() * (1.0 / RAND_MAX);
		u2 = rand() * (1.0 / RAND_MAX);
	} while ( u1 <= epsilon );

	*z0 = *z0 + (sqrt(-2.0 * log(u1)) * cos(two_pi * u2) * sigma) * RAND_MAX;
	*z1 = *z1 + (sqrt(-2.0 * log(u1)) * sin(two_pi * u2) * sigma) * RAND_MAX;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x28, %rsp
movsd %xmm0, 0x20(%rsp)
movq %rsi, %rbx
movq %rdi, %r14
callq 0x1240
cvtsi2sd %eax, %xmm0
mulsd 0x7273(%rip), %xmm0     # 0x1de08
movsd %xmm0, (%rsp)
callq 0x1240
movsd (%rsp), %xmm0
movsd 0x7264(%rip), %xmm1     # 0x1de10
ucomisd %xmm0, %xmm1
jae 0x16b84
cvtsi2sd %eax, %xmm1
mulsd 0x724a(%rip), %xmm1     # 0x1de08
movsd %xmm1, 0x10(%rsp)
cvtsi2sdl (%r14), %xmm1
movsd %xmm1, 0x8(%rsp)
callq 0x10e0
mulsd 0x723c(%rip), %xmm0     # 0x1de18
xorpd %xmm1, %xmm1
ucomisd %xmm1, %xmm0
jb 0x16bec
sqrtsd %xmm0, %xmm0
jmp 0x16bf1
callq 0x1220
movsd %xmm0, 0x18(%rsp)
movsd 0x10(%rsp), %xmm0
mulsd 0x721b(%rip), %xmm0     # 0x1de20
movsd %xmm0, 0x10(%rsp)
callq 0x10f0
mulsd 0x18(%rsp), %xmm0
mulsd 0x20(%rsp), %xmm0
mulsd 0x720c(%rip), %xmm0     # 0x1de30
addsd 0x8(%rsp), %xmm0
cvttsd2si %xmm0, %eax
movl %eax, (%r14)
cvtsi2sdl (%rbx), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd (%rsp), %xmm0
callq 0x10e0
mulsd 0x71cb(%rip), %xmm0     # 0x1de18
ucomisd 0x71d3(%rip), %xmm0     # 0x1de28
jb 0x16c5d
sqrtsd %xmm0, %xmm0
jmp 0x16c62
callq 0x1220
movsd %xmm0, (%rsp)
movsd 0x10(%rsp), %xmm0
callq 0x11e0
mulsd (%rsp), %xmm0
mulsd 0x20(%rsp), %xmm0
mulsd 0x71ab(%rip), %xmm0     # 0x1de30
addsd 0x8(%rsp), %xmm0
cvttsd2si %xmm0, %eax
movl %eax, (%rbx)
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/randomGraphGenerators.c
// Function: randomVertexLabels
void randomVertexLabels(struct Graph* g, int nVertexLabels) {
	int i;
	for (i=0; i<g->n; ++i) {
		g->vertices[i]->label = intLabel(rand() % nVertexLabels);
		g->vertices[i]->isStringMaster = 1;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %esi, %ebx
movq %rdi, %r14
xorl %r15d, %r15d
movslq (%r14), %rax
cmpq %rax, %r15
jge 0x16cd8
callq 0x1240
cltd
idivl %ebx
movl %edx, %edi
callq 0xb405
movq 0x10(%r14), %rcx
movq (%rcx,%r15,8), %rdx
movq %rax, (%rdx)
movq (%rcx,%r15,8), %rax
movl $0x1, 0x24(%rax)
incq %r15
jmp 0x16ca6
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/randomGraphGenerators.c
// Function: makeMinDegree1
void makeMinDegree1(struct Graph* g, struct GraphPool* gp) {
	for (int v=1; v<g->n; ++v) {
		if (g->vertices[v]->neighborhood == NULL) {
			addEdgeBetweenVertices(v, v-1, intLabel(1), g, gp);
			g->vertices[v]->neighborhood->isStringMaster = 1;
		}
	}
	if (g->vertices[0]->neighborhood == NULL) {
		addEdgeBetweenVertices(0,1,intLabel(1), g, gp);
		g->vertices[0]->neighborhood->isStringMaster = 1;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
xorl %r15d, %r15d
pushq $0x1
popq %rbp
leaq 0x1(%r15), %r12
movslq (%rbx), %rcx
movq 0x10(%rbx), %rax
cmpq %rcx, %r12
jge 0x16d42
movq 0x8(%rax,%r15,8), %rax
cmpq $0x0, 0x8(%rax)
jne 0x16d3d
movl %ebp, %edi
callq 0xb405
movl %r12d, %edi
movl %r15d, %esi
movq %rax, %rdx
movq %rbx, %rcx
movq %r14, %r8
callq 0x6200
movq 0x10(%rbx), %rax
movq 0x8(%rax,%r15,8), %rax
movq 0x8(%rax), %rax
movl $0x1, 0x28(%rax)
movq %r12, %r15
jmp 0x16cf2
movq (%rax), %rax
cmpq $0x0, 0x8(%rax)
jne 0x16d7a
pushq $0x1
popq %rbp
movl %ebp, %edi
callq 0xb405
xorl %edi, %edi
movl %ebp, %esi
movq %rax, %rdx
movq %rbx, %rcx
movq %r14, %r8
callq 0x6200
movq 0x10(%rbx), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movl $0x1, 0x28(%rax)
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/randomGraphGenerators.c
// Function: erdosRenyi
struct Graph* erdosRenyi(int n, double p, struct GraphPool* gp) {
	struct Graph* g = createGraph(n, gp);
	for (int i=0; i<n; ++i) {
		for (int j=i+1; j<n; ++j) {
			double value = rand() / (RAND_MAX + 1.0);
			if (value < p) {
				addEdgeBetweenVertices(i, j, NULL, g, gp);
			}
		}
	}
	return g;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movsd %xmm0, 0x10(%rsp)
movl %edi, %ebp
callq 0x630e
movq %rax, %r14
xorl %r15d, %r15d
testl %ebp, %ebp
movl $0x0, %eax
cmovgl %ebp, %eax
movl %eax, 0xc(%rsp)
cmpl 0xc(%rsp), %r15d
je 0x16e02
leal 0x1(%r15), %r13d
movl %r13d, %r12d
cmpl %ebp, %r12d
jge 0x16dfd
callq 0x1240
cvtsi2sd %eax, %xmm0
mulsd 0x705f(%rip), %xmm0     # 0x1de38
movsd 0x10(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x16df8
movl %r15d, %edi
movl %r12d, %esi
xorl %edx, %edx
movq %r14, %rcx
movq %rbx, %r8
callq 0x6200
incl %r12d
jmp 0x16dc3
movl %r13d, %r15d
jmp 0x16db5
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/randomGraphGenerators.c
// Function: erdosRenyiWithLabels
struct Graph* erdosRenyiWithLabels(int n, double p, int nVertexLabels, int nEdgeLabels, struct GraphPool* gp) {
	struct Graph* g = createGraph(n, gp);
	randomVertexLabels(g, nVertexLabels);

	for (int i=0; i<n; ++i) {
		for (int j=i+1; j<n; ++j) {
			double value = rand() / (RAND_MAX + 1.0);
			if (value < p) {
				// add a labeled edge and set one of the two resulting vertex lists as string master.
				addEdgeBetweenVertices(i, j, intLabel(rand() % nEdgeLabels), g, gp);
				g->vertices[i]->neighborhood->isStringMaster = 1;
			}
		}
	}
	return g;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movl %edx, %ebp
movl %esi, %r12d
movsd %xmm0, 0x10(%rsp)
movl %edi, %r14d
movq %rcx, %rsi
callq 0x630e
movq %rax, %r15
movq %rax, %rdi
movl %r12d, %esi
callq 0x16c99
xorl %r12d, %r12d
testl %r14d, %r14d
movl $0x0, %eax
cmovgl %r14d, %eax
movq %rax, (%rsp)
cmpq (%rsp), %r12
je 0x16ed3
leaq 0x1(%r12), %rax
movq %rax, 0x8(%rsp)
movl %eax, %r13d
cmpl %r14d, %r13d
jge 0x16ecc
callq 0x1240
cvtsi2sd %eax, %xmm0
mulsd 0x6fb3(%rip), %xmm0     # 0x1de38
movsd 0x10(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x16ec7
callq 0x1240
cltd
idivl %ebp
movl %edx, %edi
callq 0xb405
movl %r12d, %edi
movl %r13d, %esi
movq %rax, %rdx
movq %r15, %rcx
movq %rbx, %r8
callq 0x6200
movq 0x10(%r15), %rax
movq (%rax,%r12,8), %rax
movq 0x8(%rax), %rax
movl $0x1, 0x28(%rax)
incl %r13d
jmp 0x16e6f
movq 0x8(%rsp), %r12
jmp 0x16e5c
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/randomGraphGenerators.c
// Function: euclideanDistance
inline double euclideanDistance(const int vx, const int vy, const int wx, const int wy) {
	double vxx = vx / (double)RAND_MAX;
	double vyy = vy / (double)RAND_MAX;
	double wxx = wx / (double)RAND_MAX;
	double wyy = wy / (double)RAND_MAX;
	double xdiff = vxx - wxx;
	double ydiff = vyy - wyy;
	double result = sqrt(xdiff * xdiff + ydiff * ydiff);
	return result;
}

// Assembly:
movd %edx, %xmm0
movd %edi, %xmm1
punpckldq %xmm0, %xmm1    # xmm1 = xmm1[0],xmm0[0],xmm1[1],xmm0[1]
cvtdq2pd %xmm1, %xmm0
movd %ecx, %xmm1
movd %esi, %xmm2
punpckldq %xmm1, %xmm2    # xmm2 = xmm2[0],xmm1[0],xmm2[1],xmm1[1]
cvtdq2pd %xmm2, %xmm1
movapd 0x6950(%rip), %xmm2     # 0x1de40
divpd %xmm2, %xmm0
divpd %xmm2, %xmm1
movapd %xmm0, %xmm2
unpckhpd %xmm0, %xmm2            # xmm2 = xmm2[1],xmm0[1]
subsd %xmm2, %xmm0
movapd %xmm1, %xmm2
unpckhpd %xmm1, %xmm2            # xmm2 = xmm2[1],xmm1[1]
subsd %xmm2, %xmm1
mulsd %xmm1, %xmm1
mulsd %xmm0, %xmm0
addsd %xmm1, %xmm0
sqrtsd %xmm0, %xmm0
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/randomGraphGenerators.c
// Function: printOverlapGraphDotFormat
void printOverlapGraphDotFormat(struct Graph* g, FILE* out) {
	fprintf(out, "graph %i {\n", g->number);
	for (int v=0; v<g->n; ++v) {
		fprintf(out, "%i [label=%s, pos=\"%lf,%lf\", pin=true, shape=point];\n", v, g->vertices[v]->label, g->vertices[v]->d / (double)RAND_MAX, g->vertices[v]->lowPoint / (double)RAND_MAX);
	}
	for (int v=0; v<g->n; ++v) {
		for (struct VertexList* e=g->vertices[v]->neighborhood; e!=NULL; e=e->next) {
			if (e->startPoint->number < e->endPoint->number) {
				fprintf(out, "%i -- %i;\n", e->startPoint->number, e->endPoint->number);
			}
		}
	}
	fprintf(out, "}\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl 0x8(%rdi), %edx
leaq 0x5e41(%rip), %rsi      # 0x1d3a0
xorl %r15d, %r15d
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1150
leaq 0x68dd(%rip), %r12      # 0x1de50
movslq (%r14), %rax
cmpq %rax, %r15
jge 0x175b5
movq 0x10(%r14), %rax
movq (%rax,%r15,8), %rax
movq (%rax), %rcx
cvtsi2sdl 0x28(%rax), %xmm0
movsd 0x689d(%rip), %xmm2     # 0x1de30
divsd %xmm2, %xmm0
cvtsi2sdl 0x20(%rax), %xmm1
divsd %xmm2, %xmm1
movq %rbx, %rdi
movq %r12, %rsi
movl %r15d, %edx
movb $0x2, %al
callq 0x1150
incq %r15
jmp 0x17573
leaq 0x68ca(%rip), %r15      # 0x1de86
xorl %r12d, %r12d
cltq
cmpq %rax, %r12
jge 0x17600
movq 0x10(%r14), %rax
movq (%rax,%r12,8), %r13
movq 0x8(%r13), %r13
testq %r13, %r13
je 0x175f8
movq 0x10(%r13), %rax
movq 0x18(%r13), %rcx
movl 0x18(%rax), %edx
movl 0x18(%rcx), %ecx
cmpl %ecx, %edx
jge 0x175ce
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x1150
jmp 0x175ce
incq %r12
movl (%r14), %eax
jmp 0x175bf
leaq 0x5dbb(%rip), %rdi      # 0x1d3c2
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1210
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/randomGraphGenerators.c
// Function: randomOverlapGraph
struct Graph* randomOverlapGraph(int n, double d, struct GraphPool* gp) {
	struct Graph* g = createGraph(n, gp);

	// every vertex is a two-dimensional point
	for (int v=0; v<n; ++v) {
		g->vertices[v]->d = rand();
		g->vertices[v]->lowPoint = rand();
		g->vertices[v]->label = intLabel(1);
	}
	// add edge iff distance is smaller than d
	for (int v=0; v<n; ++v) {
		for (int w=v+1; w<n; ++w) {
			if (euclideanDistanceWrap(v, w, g) < d) {
				addEdgeBetweenVertices(v, w, intLabel(1), g, gp);
			}
		}
	}
	return g;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movsd %xmm0, 0x10(%rsp)
movl %edi, %ebp
callq 0x630e
movq %rax, %r14
xorl %r12d, %r12d
testl %ebp, %ebp
movl $0x0, %r13d
cmovgl %ebp, %r13d
pushq $0x1
popq %r15
cmpq %r12, %r13
je 0x1768f
callq 0x1240
movq 0x10(%r14), %rcx
movq (%rcx,%r12,8), %rcx
movl %eax, 0x28(%rcx)
callq 0x1240
movq 0x10(%r14), %rcx
movq (%rcx,%r12,8), %rcx
movl %eax, 0x20(%rcx)
movl %r15d, %edi
callq 0xb405
movq 0x10(%r14), %rcx
movq (%rcx,%r12,8), %rcx
movq %rax, (%rcx)
incq %r12
jmp 0x17652
xorl %r15d, %r15d
pushq $0x1
popq %r12
movq %r13, 0x8(%rsp)
cmpl %r13d, %r15d
je 0x176f7
leal 0x1(%r15), %r13d
movl %r13d, 0x4(%rsp)
cmpl %ebp, %r13d
jge 0x176e9
movl %r15d, %edi
movl %r13d, %esi
movq %r14, %rdx
callq 0x17521
movsd 0x10(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x176e4
movl %r12d, %edi
callq 0xb405
movl %r15d, %edi
movl %r13d, %esi
movq %rax, %rdx
movq %r14, %rcx
movq %rbx, %r8
callq 0x6200
incl %r13d
jmp 0x176a9
movl 0x4(%rsp), %eax
movl %eax, %r15d
movq 0x8(%rsp), %r13
jmp 0x1769b
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/randomGraphGenerators.c
// Function: randomOverlapGraphWithLabels
struct Graph* randomOverlapGraphWithLabels(int n, double d, int nVertexLabels, struct GraphPool* gp) {
	struct Graph* g = createGraph(n, gp);

	// every vertex is a two-dimensional point
	for (int v=0; v<n; ++v) {
		g->vertices[v]->d = rand();
		g->vertices[v]->lowPoint = rand();
		g->vertices[v]->label = intLabel(rand() % nVertexLabels);
	}
	// add edge iff distance is smaller than d
	for (int v=0; v<n; ++v) {
		for (int w=v+1; w<n; ++w) {
			if (euclideanDistanceWrap(v, w, g) < d) {
				addEdgeBetweenVertices(v, w, intLabel(1), g, gp);
			}
		}
	}
	return g;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movl %esi, %r15d
movsd %xmm0, 0x10(%rsp)
movl %edi, %ebp
movq %rdx, %rsi
callq 0x630e
movq %rax, %r14
xorl %r12d, %r12d
testl %ebp, %ebp
movl $0x0, %r13d
cmovgl %ebp, %r13d
cmpq %r12, %r13
je 0x17784
callq 0x1240
movq 0x10(%r14), %rcx
movq (%rcx,%r12,8), %rcx
movl %eax, 0x28(%rcx)
callq 0x1240
movq 0x10(%r14), %rcx
movq (%rcx,%r12,8), %rcx
movl %eax, 0x20(%rcx)
callq 0x1240
cltd
idivl %r15d
movl %edx, %edi
callq 0xb405
movq 0x10(%r14), %rcx
movq (%rcx,%r12,8), %rcx
movq %rax, (%rcx)
incq %r12
jmp 0x1773f
xorl %r15d, %r15d
pushq $0x1
popq %r12
movq %r13, 0x8(%rsp)
cmpl %r13d, %r15d
je 0x177ec
leal 0x1(%r15), %r13d
movl %r13d, 0x4(%rsp)
cmpl %ebp, %r13d
jge 0x177de
movl %r15d, %edi
movl %r13d, %esi
movq %r14, %rdx
callq 0x17521
movsd 0x10(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x177d9
movl %r12d, %edi
callq 0xb405
movl %r15d, %edi
movl %r13d, %esi
movq %rax, %rdx
movq %r14, %rcx
movq %rbx, %r8
callq 0x6200
incl %r13d
jmp 0x1779e
movl 0x4(%rsp), %eax
movl %eax, %r15d
movq 0x8(%rsp), %r13
jmp 0x17790
movq %r14, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/randomGraphGenerators.c
// Function: moveVertexGaussian
void moveVertexGaussian(struct Vertex* v, double moveParameter) {
	generateIntegerGaussianNoise(&(v->d), &(v->lowPoint), moveParameter);
	// mirror in unit interval
	// stupid undefined behavior of abs(INT_MIN) requires to do it ourselves:
	int a = v->d;
	int b = v->lowPoint;
	v->d = a == INT_MIN ? RAND_MAX : abs(a);
	v->lowPoint = b == INT_MIN ? RAND_MAX : abs(b);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
addq $0x28, %rdi
leaq 0x20(%rbx), %rsi
callq 0x16b71
movl 0x28(%rbx), %eax
movl %eax, %ecx
negl %ecx
cmovsl %eax, %ecx
movl 0x20(%rbx), %eax
movl $0x7fffffff, %edx       # imm = 0x7FFFFFFF
cmovol %edx, %ecx
movl %eax, %esi
negl %esi
cmovsl %eax, %esi
movl %ecx, 0x28(%rbx)
cmovol %edx, %esi
movl %esi, 0x20(%rbx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/randomGraphGenerators.c
// Function: moveOverlapGraph
void moveOverlapGraph(struct Graph* g, double moveParameter, double d, struct GraphPool* gp) {

	// move vertices
	for (int v=0; v<g->n; ++v) {
		moveVertexGaussian(g->vertices[v], moveParameter);
	}

	// dump edges
	for (int v=0; v<g->n; ++v) {
		dumpVertexListRecursively(gp->listPool, g->vertices[v]->neighborhood);
		g->vertices[v]->neighborhood = NULL;
	}
	g->m = 0;

	// add edge iff distance is smaller than d
	for (int v=0; v<g->n; ++v) {
		for (int w=v+1; w<g->n; ++w) {
			if (euclideanDistanceWrap(v, w, g) < d) {
				addEdgeBetweenVertices(v, w, intLabel(1), g, gp);
				g->vertices[v]->neighborhood->isStringMaster = 1;
			}
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movsd %xmm1, 0x10(%rsp)
movsd %xmm0, 0x8(%rsp)
movq %rdi, %r14
xorl %r15d, %r15d
movslq (%r14), %r13
cmpq %r13, %r15
jge 0x17a9e
movq 0x10(%r14), %rax
movq (%rax,%r15,8), %rdi
movsd 0x8(%rsp), %xmm0
callq 0x177fe
incq %r15
jmp 0x17a7e
xorl %r15d, %r15d
movslq %r13d, %rax
cmpq %rax, %r15
jge 0x17ad3
movq 0x18(%rbx), %rdi
movq 0x10(%r14), %rax
movq (%rax,%r15,8), %rax
movq 0x8(%rax), %rsi
callq 0x1138e
movq 0x10(%r14), %rax
movq (%rax,%r15,8), %rax
andq $0x0, 0x8(%rax)
incq %r15
movl (%r14), %r13d
jmp 0x17aa1
andl $0x0, 0x4(%r14)
xorl %r15d, %r15d
pushq $0x1
popq %rbp
movslq %r13d, %rax
cmpq %rax, %r15
jge 0x17b4e
leaq 0x1(%r15), %rax
movq %rax, 0x8(%rsp)
movl %eax, %r12d
cmpl %r13d, %r12d
jge 0x17b47
movl %r15d, %edi
movl %r12d, %esi
movq %r14, %rdx
callq 0x17521
movsd 0x10(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0x17b42
movl %ebp, %edi
callq 0xb405
movl %r15d, %edi
movl %r12d, %esi
movq %rax, %rdx
movq %r14, %rcx
movq %rbx, %r8
callq 0x6200
movq 0x10(%r14), %rax
movq (%rax,%r15,8), %rax
movq 0x8(%rax), %rax
movl $0x1, 0x28(%rax)
movl (%r14), %r13d
incl %r12d
jmp 0x17af2
movq 0x8(%rsp), %r15
jmp 0x17ade
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/sampleSubtrees.c
// Function: sampleSpanningTreeEdgesFromCactus
struct ShallowGraph* sampleSpanningTreeEdgesFromCactus(struct ShallowGraph* biconnectedComponents, struct ShallowGraphPool* sgp) {
	struct ShallowGraph* spanningTree = getShallowGraph(sgp);
	struct ShallowGraph* idx;
	for (idx=biconnectedComponents; idx!=NULL; idx=idx->next) {
		if (idx->m == 1) {
			appendEdge(spanningTree, shallowCopyEdge(idx->edges, sgp->listPool));
		} else {
			int removalEdgeId = rand() % idx->m;
			struct VertexList* e;
			int i = 0;
			for (e=idx->edges; e!=NULL; e=e->next) {
				if (i != removalEdgeId) {
					appendEdge(spanningTree, shallowCopyEdge(e, sgp->listPool));
				}
				++i;
			}
		}
	}
	return spanningTree;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x117e9
movq %rax, %r15
testq %r14, %r14
je 0x17bdc
cmpl $0x1, 0x10(%r14)
jne 0x17ba2
movq (%r14), %rdi
movq 0x10(%rbx), %rsi
callq 0x5a28
movq %r15, %rdi
movq %rax, %rsi
callq 0x6620
movq 0x18(%r14), %r14
jmp 0x17b79
callq 0x1240
cltd
idivl 0x10(%r14)
movl %edx, %ebp
movq %r14, %r12
movq (%r12), %r12
testq %r12, %r12
je 0x17b9c
subl $0x1, %ebp
jb 0x17bd6
movq 0x10(%rbx), %rsi
movq %r12, %rdi
callq 0x5a28
movq %r15, %rdi
movq %rax, %rsi
callq 0x6620
addq $0x8, %r12
jmp 0x17bb1
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/sampleSubtrees.c
// Function: sampleSpanningTreeFromCactus
struct Graph* sampleSpanningTreeFromCactus(struct Graph* original, struct ShallowGraph* biconnectedComponents, struct GraphPool* gp) {
	struct Graph* spanningTree = emptyGraph(original, gp);
	struct ShallowGraph* idx;
	for (idx=biconnectedComponents; idx!=NULL; idx=idx->next) {
		if (idx->m == 1) {
			addEdgeBetweenVertices(idx->edges->startPoint->number, idx->edges->endPoint->number, idx->edges->label, spanningTree, gp);
		} else {
			int removalEdgeId = rand() % idx->m;
			struct VertexList* e;
			int i = 0;
			for (e=idx->edges; e!=NULL; e=e->next) {
				if (i != removalEdgeId) {
					addEdgeBetweenVertices(e->startPoint->number, e->endPoint->number, e->label, spanningTree, gp);
				}
				++i;
			}
		}
	}
	return spanningTree;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdx, %rsi
callq 0x62b2
movq %rax, %r15
testq %r14, %r14
je 0x17c74
cmpl $0x1, 0x10(%r14)
jne 0x17c32
movq (%r14), %rax
movq (%rax), %rdx
movq 0x10(%rax), %rcx
movl 0x18(%rcx), %edi
movq 0x18(%rax), %rax
movl 0x18(%rax), %esi
movq %r15, %rcx
movq %rbx, %r8
callq 0x6200
movq 0x18(%r14), %r14
jmp 0x17c01
callq 0x1240
cltd
idivl 0x10(%r14)
movl %edx, %ebp
movq %r14, %r12
movq (%r12), %r12
testq %r12, %r12
je 0x17c2c
subl $0x1, %ebp
jb 0x17c6e
movq (%r12), %rdx
movq 0x10(%r12), %rax
movl 0x18(%rax), %edi
movq 0x18(%r12), %rax
movl 0x18(%rax), %esi
movq %r15, %rcx
movq %rbx, %r8
callq 0x6200
addq $0x8, %r12
jmp 0x17c41
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/sampleSubtrees.c
// Function: sampleSpanningTreesUsingWilson
struct ShallowGraph* sampleSpanningTreesUsingWilson(struct Graph* g, int k, struct ShallowGraphPool* sgp) {
	struct ShallowGraph* spanningTrees = NULL;
	int j;
	for (j=0; j<k; ++j) {
		struct ShallowGraph* spanningTree = randomSpanningTreeAsShallowGraph(g, sgp);
		spanningTree->next = spanningTrees;
		spanningTrees = spanningTree;
	}
	return spanningTrees;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
xorl %r15d, %r15d
testl %esi, %esi
cmovlel %r15d, %ebp
subl $0x1, %ebp
jb 0x17cb1
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1bdd7
movq %r15, 0x18(%rax)
movq %rax, %r15
jmp 0x17c98
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/sampleSubtrees.c
// Function: shuffle
void shuffle(struct VertexList** array, size_t n) {
    // struct timeval tv;
    // gettimeofday(&tv, NULL);
    // int usec = tv.tv_usec;
    // srand48(usec);

    if (n > 1) {
        size_t i;
        for (i = n - 1; i > 0; i--) {
            size_t j = (unsigned int) (rand() % i);
            struct VertexList* t = array[j];
            array[j] = array[i];
            array[i] = t;
        }
    }
}

// Assembly:
cmpq $0x2, %rsi
jb 0x17d17
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r14
movq %rdi, %rbx
decq %r14
movq %r14, %r15
subq $0x1, %r15
jb 0x17d12
callq 0x1240
cltq
xorl %edx, %edx
divq %r14
movl %edx, %eax
movq (%rbx,%rax,8), %rcx
movq (%rbx,%r14,8), %rdx
movq %rdx, (%rbx,%rax,8)
movq %rcx, (%rbx,%r14,8)
movq %r15, %r14
jmp 0x17ce9
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/sampleSubtrees.c
// Function: sampleSpanningTreesUsingKruskalOnce
struct ShallowGraph* sampleSpanningTreesUsingKruskalOnce(struct Graph* g, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	struct ShallowGraph* spanningTree = NULL;
	int i;

	// create and shuffle array of edges of g
	struct ShallowGraph* edges = getGraphEdges(g, sgp);
	struct VertexList** edgeArray = malloc(g->m * sizeof(struct VertexList*));
	if (edges->m != 0) {
		edgeArray[0] = edges->edges;
	}
	for (i=1; i < g->m; ++i) {
		edgeArray[i] = edgeArray[i-1]->next;
	}
	shuffle(edgeArray, g->m);

	// do the kruskal
	spanningTree = kruskalMST(g, edgeArray, gp, sgp);

	// garbage collection
	dumpShallowGraphCycle(sgp, edges);
	free(edgeArray);

	return spanningTree;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
movq %rdx, %rsi
callq 0x6172
movq %rax, %r14
movslq 0x4(%r12), %rbp
leaq (,%rbp,8), %rdi
callq 0x1180
movq %rax, %r13
cmpl $0x0, 0x10(%r14)
je 0x17d5a
movq (%r14), %rax
movq %rax, (%r13)
pushq $0x1
popq %rax
cmpq %rbp, %rax
jge 0x17d75
movq -0x8(%r13,%rax,8), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, (%r13,%rax,8)
incq %rax
jmp 0x17d5d
movq %r13, %rdi
movq %rbp, %rsi
callq 0x17cd2
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rdx
movq %rbx, %rcx
callq 0x89dc
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x11888
movq %r13, %rdi
callq 0x1030
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/sampleSubtrees.c
// Function: sampleSpanningTreesUsingKruskal
struct ShallowGraph* sampleSpanningTreesUsingKruskal(struct Graph* g, int k, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	struct ShallowGraph* spanningTrees = NULL;
	int i;

	for (i=0; i<k; ++i) {
		struct ShallowGraph* tmp = sampleSpanningTreesUsingKruskalOnce(g, gp, sgp);
		tmp->next = spanningTrees;
		spanningTrees = tmp;
	}
	return spanningTrees;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rcx, %rbx
movq %rdx, %r14
movl %esi, %ebp
movq %rdi, %r15
xorl %r12d, %r12d
testl %esi, %esi
cmovlel %r12d, %ebp
subl $0x1, %ebp
jb 0x17dfc
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x17d18
movq %r12, 0x18(%rax)
movq %rax, %r12
jmp 0x17de0
movq %r12, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/sampleSubtrees.c
// Function: sampleSpanningTreesUsingListing
struct ShallowGraph* sampleSpanningTreesUsingListing(struct Graph* g, int k, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	struct ShallowGraph* spanningTrees = NULL;
	struct ShallowGraph* trees = listSpanningTrees(g, sgp, gp);
	struct ShallowGraph** array;
	
	struct ShallowGraph* idx;
	int j;
	int nTrees = 0;

	/* find number of listed trees, put them in array */
	for (idx=trees; idx; idx=idx->next) ++nTrees;

	array = malloc(nTrees * sizeof(struct ShallowGraph*));
	j = 0;
	for (idx=trees; idx; idx=idx->next) {	
		array[j] = idx;
		++j;
	}

	/* sample k trees uniformly at random */
	for (j=0; j<k; ++j) {
		int rnd = rand() % nTrees;
		// can't just use the listed tree itself, as it might get selected more than once
		struct ShallowGraph* tree = cloneShallowGraph(array[rnd], sgp);
		tree->next = spanningTrees;
		spanningTrees = tree;
	}
	dumpShallowGraphCycle(sgp, trees);
	free(array);
	return spanningTrees;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %esi, %ebp
movq %rcx, %rsi
callq 0xa01b
movq %rax, %r14
xorl %edi, %edi
xorl %r13d, %r13d
testq %rax, %rax
je 0x17e45
incl %r13d
movq 0x18(%rax), %rax
addq $0x8, %rdi
jmp 0x17e33
callq 0x1180
movq %rax, %r15
movq %r14, %rcx
testq %rcx, %rcx
je 0x17e62
movq %rcx, (%rax)
movq 0x18(%rcx), %rcx
addq $0x8, %rax
jmp 0x17e50
xorl %r12d, %r12d
testl %ebp, %ebp
cmovlel %r12d, %ebp
subl $0x1, %ebp
jb 0x17e91
callq 0x1240
cltd
idivl %r13d
movslq %edx, %rax
movq (%r15,%rax,8), %rdi
movq %rbx, %rsi
callq 0x659e
movq %r12, 0x18(%rax)
movq %rax, %r12
jmp 0x17e6b
movq %rbx, %rdi
movq %r14, %rsi
callq 0x11888
movq %r15, %rdi
callq 0x1030
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/sampleSubtrees.c
// Function: sampleSpanningTreesUsingMix
struct ShallowGraph* sampleSpanningTreesUsingMix(struct Graph* g, int k, long int threshold, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	long upperBound = getGoodEstimate(g, sgp, gp);
	if ((upperBound < threshold) && (upperBound != -1)) {
		return sampleSpanningTreesUsingListing(g, k, gp, sgp);
	} else {
		return sampleSpanningTreesUsingWilson(g, k, sgp);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r12
movl %esi, %ebp
movq %rdi, %r15
movq %r8, %rsi
movq %rcx, %rdx
callq 0x1b8c6
cmpq %r12, %rax
setge %cl
cmpq $-0x1, %rax
sete %al
movq %r15, %rdi
movl %ebp, %esi
orb %cl, %al
jne 0x17f0b
movq %r14, %rdx
movq %rbx, %rcx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x17e13
movq %rbx, %rdx
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
jmp 0x17c80
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/sampleSubtrees.c
// Function: sampleSpanningTreesUsingPartialListingMix
struct ShallowGraph* sampleSpanningTreesUsingPartialListingMix(struct Graph* g, int k, long int threshold, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	long upperBound = getGoodEstimate(g, sgp, gp);

	if (k != 1) {
		fprintf(stderr, "This method will only sample one spanning tree, you asked for %i\n", k);
		k = 1;
	}
	if ((upperBound < threshold) && (upperBound != -1)) {
		int i = rand() % threshold;
		int storeI = i;
		struct ShallowGraph* garbage = listKSpanningTrees(g, &i, sgp, gp);
		if (i == 0) {
			struct ShallowGraph* result = garbage->prev;
			result->prev->next=garbage;
			dumpShallowGraphCycle(sgp, garbage);
			return result;
		} else {
			// TODO: do something sensible
			struct ShallowGraph* result = garbage->prev;
			result->prev->next=garbage;
			dumpShallowGraphCycle(sgp, garbage);
			fprintf(stderr, "oversampled! i=%i leftover=%i\n", i, storeI);
			return result;
		}
	} else {
		return sampleSpanningTreesUsingWilson(g, k, sgp);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r12
movl %esi, %ebp
movq %rdi, %r15
movq %r8, %rsi
movq %rcx, %rdx
callq 0x1b8c6
movq %rax, %r13
cmpl $0x1, %ebp
jne 0x17fd7
cmpq %r12, %r13
setge %al
cmpq $-0x1, %r13
sete %cl
orb %al, %cl
jne 0x17fbb
callq 0x1240
cltq
cqto
idivq %r12
movq %rdx, %r12
leaq 0x4(%rsp), %r13
movl %r12d, (%r13)
movq %r15, %rdi
movq %r13, %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq 0xa362
movl (%r13), %ebp
movq 0x20(%rax), %r14
movq 0x20(%r14), %rcx
movq %rax, 0x18(%rcx)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x11888
testl %ebp, %ebp
jne 0x17ff6
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
pushq $0x1
popq %rsi
movq %r15, %rdi
movq %rbx, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x17c80
movq 0x1201a(%rip), %rax     # 0x29ff8
movq (%rax), %rdi
leaq 0x5f2f(%rip), %rsi      # 0x1df17
movl %ebp, %edx
xorl %eax, %eax
callq 0x1150
jmp 0x17f50
movq 0x11ffb(%rip), %rax     # 0x29ff8
movq (%rax), %rdi
movl 0x4(%rsp), %edx
leaq 0x5f4e(%rip), %rsi      # 0x1df59
movl %r12d, %ecx
xorl %eax, %eax
callq 0x1150
jmp 0x17fa9
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/sampleSubtrees.c
// Function: sampleSpanningTreesUsingCactusMix
struct ShallowGraph* sampleSpanningTreesUsingCactusMix(struct Graph* g, int k, long int threshold, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	struct ShallowGraph* spanningTrees = NULL;
	struct ShallowGraph* biconnectedComponents = listBiconnectedComponents(g, sgp);
	int blockCount = 0;
	struct ShallowGraph* idx;
	for (idx=biconnectedComponents; idx!=NULL; idx=idx->next) {
		if (idx->m > 1) {
			++blockCount;
		}
	}
	/* if g is a cactus graph */
	if (g->n - 1 + blockCount == g->m) {
		int j;
		for (j=0; j<k; ++j) {	
			struct ShallowGraph* spanningTree = sampleSpanningTreeEdgesFromCactus(biconnectedComponents, sgp);
			spanningTree->next = spanningTrees;
			spanningTrees = spanningTree;
		}
	} else {
		// for speedup. this is sampleSpanningTreesUsingMix
		long upperBound = getGoodEstimatePrecomputedBlocks(g, biconnectedComponents, sgp, gp);
		if ((upperBound < threshold) && (upperBound != -1)) {
			spanningTrees = sampleSpanningTreesUsingListing(g, k, gp, sgp);
		} else {
			spanningTrees = sampleSpanningTreesUsingWilson(g, k, sgp);
		}
	}
	dumpShallowGraphCycle(sgp, biconnectedComponents);
	return spanningTrees;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r15
movq %rdx, %r13
movl %esi, %ebp
movq %rdi, %r12
movq %r8, %rsi
callq 0x8ccd
movq %rax, %r14
xorl %eax, %eax
movq %r14, %rcx
testq %rcx, %rcx
je 0x1805b
xorl %edx, %edx
cmpl $0x2, 0x10(%rcx)
setge %dl
addl %edx, %eax
movq 0x18(%rcx), %rcx
jmp 0x18045
movl (%r12), %ecx
addl %ecx, %eax
decl %eax
cmpl 0x4(%r12), %eax
jne 0x1808c
xorl %r15d, %r15d
testl %ebp, %ebp
cmovlel %r15d, %ebp
subl $0x1, %ebp
jb 0x180cb
movq %r14, %rdi
movq %rbx, %rsi
callq 0x17b60
movq %r15, 0x18(%rax)
movq %rax, %r15
jmp 0x18073
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r15, %rcx
callq 0x1b90d
cmpq %r13, %rax
setge %cl
cmpq $-0x1, %rax
sete %al
movq %r12, %rdi
movl %ebp, %esi
orb %cl, %al
jne 0x180c0
movq %r15, %rdx
movq %rbx, %rcx
callq 0x17e13
jmp 0x180c8
movq %rbx, %rdx
callq 0x17c80
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x11888
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq