LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/localEasySubtreeIsomorphism.c
// Function: filterDuplicateSpanningTrees
struct ShallowGraph* filterDuplicateSpanningTrees(struct ShallowGraph* sptrees, struct ShallowGraphPool* sgp) {
	struct ShallowGraph* filteredResult = NULL;

	// sort edges in spanning trees, count number of spts
	size_t length = 0;
	for (struct ShallowGraph* l=sptrees; l!=NULL; l=l->next) {
		sortShallowGraphEdges(l, &absCompEdges);
		++length;
	}

	filteredResult = sortListOfShallowGraphs(sptrees, length, &absCompShallowGraphs);
	filteredResult = filterSortedSpanningTreeList(filteredResult, &compareShallowGraphsAbsloute, sgp);

	return filteredResult;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
testq %rdi, %rdi
je 0xefa0
movq %rdi, %rbx
movq %r14, (%rsp)
xorl %r12d, %r12d
leaq -0x1c3(%rip), %r15      # 0xecb2
movq %rdi, %r14
movq %r12, %rbp
movslq 0x10(%r14), %r13
cmpq $0x2, %r13
jl 0xef12
leaq (,%r13,8), %rdi
callq 0x1190
movq %rax, %r12
movq (%r14), %rax
movq %rax, (%r12)
movl $0x1, %eax
movq -0x8(%r12,%rax,8), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, (%r12,%rax,8)
incq %rax
cmpq %rax, %r13
jne 0xeea5
movl $0x8, %edx
movq %r12, %rdi
movq %r13, %rsi
movq %r15, %rcx
callq 0x1080
movl 0x10(%r14), %ecx
leal -0x1(%rcx), %eax
cmpl $0x2, %ecx
jl 0xeef5
movl %eax, %ecx
movq (%r12), %rdx
xorl %esi, %esi
movq 0x8(%r12,%rsi,8), %rdi
incq %rsi
movq %rdi, 0x8(%rdx)
movq %rdi, %rdx
cmpq %rsi, %rcx
jne 0xeee1
cltq
movq (%r12,%rax,8), %rax
movq $0x0, 0x8(%rax)
movq (%r12), %rax
movq %rax, (%r14)
movq %r12, %rdi
callq 0x1030
leaq 0x1(%rbp), %r12
movq 0x18(%r14), %r14
testq %r14, %r14
jne 0xee78
cmpq $0x2, %r12
jb 0xefa4
leaq (,%r12,8), %rdi
callq 0x1190
movq %rax, %r15
movq %rbx, (%rax)
xorl %eax, %eax
movq (%rsp), %r14
movq (%r15,%rax,8), %rcx
movq 0x18(%rcx), %rcx
movq %rcx, 0x8(%r15,%rax,8)
incq %rax
cmpq %rax, %rbp
jne 0xef42
leaq -0x1df(%rip), %rcx      # 0xed7f
movl $0x8, %edx
movq %r15, %rdi
movq %r12, %rsi
callq 0x1080
movq (%r15), %rcx
xorl %eax, %eax
movq 0x8(%r15,%rax,8), %rdx
incq %rax
movq %rdx, 0x18(%rcx)
movq %rdx, %rcx
cmpq %rax, %rbp
jne 0xef73
movq (%r15,%rbp,8), %rax
movq $0x0, 0x18(%rax)
movq (%r15), %rbx
movq %r15, %rdi
callq 0x1030
jmp 0xefa8
xorl %ebx, %ebx
jmp 0xefa8
movq (%rsp), %r14
leaq -0x271(%rip), %rsi      # 0xed3e
movq %rbx, %rdi
movq %r14, %rdx
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xedc6
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/localEasySubtreeIsomorphism.c
// Function: mergeShallowGraphs
static struct ShallowGraph* mergeShallowGraphs(struct ShallowGraph* list, struct ShallowGraphPool* sgp) {
	struct ShallowGraph* head = popShallowGraph(&list);

	for (struct ShallowGraph* pop=popShallowGraph(&list); pop!=NULL; pop=popShallowGraph(&list)) {
		mergeTwoShallowGraphs(head, pop, sgp);
	}
	return head;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
testq %rdi, %rdi
je 0xf241
movq %rsi, %r14
movq 0x18(%rbx), %rsi
movq $0x0, 0x18(%rbx)
testq %rsi, %rsi
je 0xf241
movq (%rsi), %rax
movq 0x18(%rsi), %r15
xorl %ecx, %ecx
movq %rcx, 0x18(%rsi)
movq 0x8(%rbx), %rdx
movq %rax, 0x8(%rdx)
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rbx)
movl 0x10(%rsi), %eax
addl %eax, 0x10(%rbx)
movq %rcx, 0x18(%rsi)
xorps %xmm0, %xmm0
movups %xmm0, (%rsi)
movq %r14, %rdi
callq 0x149f4
testq %r15, %r15
je 0xf241
xorl %r12d, %r12d
movq (%r15), %rax
movq 0x18(%r15), %r13
movq %r12, 0x18(%r15)
movq 0x8(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq 0x8(%r15), %rax
movq %rax, 0x8(%rbx)
movl 0x10(%r15), %eax
addl %eax, 0x10(%rbx)
movq %r12, 0x18(%r15)
xorps %xmm0, %xmm0
movups %xmm0, (%r15)
movq %r14, %rdi
movq %r15, %rsi
callq 0x149f4
movq %r13, %r15
testq %r13, %r13
jne 0xf201
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/localEasySubtreeIsomorphism.c
// Function: wipeCharacteristicsForLocalEasy
void wipeCharacteristicsForLocalEasy(struct SpanningtreeTree sptTree) {
	if (sptTree.characteristics) {
		for (int v=0; v<sptTree.nRoots; ++v) {
			struct SupportSet* list = sptTree.characteristics[v];
			if (list) {
				struct SupportSetElement* tmp;
				for (struct SupportSetElement* e=list->first; e!=NULL; e=tmp) {
					tmp = e->next;
					dumpNewCube(e->data.S, e->data.g->n);
					free(e);
				}
				list->size = 0;
				list->first = list->last = NULL;
				list->next = NULL;
			}
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq 0x60(%rsp), %r14
testq %r14, %r14
je 0xf461
leaq 0x40(%rsp), %rax
movslq 0x30(%rax), %r15
testq %r15, %r15
jle 0xf461
xorl %r12d, %r12d
movq (%r14,%r12,8), %r13
testq %r13, %r13
je 0xf459
movq (%r13), %rbx
testq %rbx, %rbx
je 0xf44c
movq 0x28(%rbx), %rbp
movq 0x8(%rbx), %rax
movq 0x18(%rbx), %rdi
movl (%rax), %esi
callq 0x161f7
movq %rbx, %rdi
callq 0x1030
movq %rbp, %rbx
testq %rbp, %rbp
jne 0xf429
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r13)
movups %xmm0, (%r13)
incq %r12
cmpq %r15, %r12
jne 0xf417
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/localEasySubtreeIsomorphism.c
// Function: dumpSpanningtreeTree
void dumpSpanningtreeTree(struct SpanningtreeTree sptTree, struct GraphPool* gp) {
	for (int v=0; v<sptTree.nRoots; ++v) {
		dumpGraphList(gp, sptTree.localSpanningTrees[v]);
		if (sptTree.characteristics) {
			if (sptTree.characteristics[v]) {
				struct SupportSetElement* tmp;
				for (struct SupportSetElement* e=sptTree.characteristics[v]->first; e!=NULL; e=tmp) {
					tmp = e->next;
					dumpNewCube(e->data.S, e->data.g->n);
					free(e);
				}
			}
			free(sptTree.characteristics[v]);
		}
		if (sptTree.localPostorders) {
			if (sptTree.localPostorders[v]) {
				struct PostorderList* tmp = NULL;
				for (struct PostorderList* l=sptTree.localPostorders[v]; l!=NULL; l=tmp) {
					tmp = l->next;
					free(l->postorder);
					free(l);
				}
			}
		}
	}
	free(sptTree.parents);
	free(sptTree.roots);
	free(sptTree.localSpanningTrees);
	free(sptTree.localPostorders);
	if (sptTree.characteristics) {
		free(sptTree.characteristics);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
leaq 0x50(%rsp), %r14
movslq 0x30(%r14), %rbp
movq 0x18(%r14), %rax
movq %rax, 0x8(%rsp)
testq %rbp, %rbp
jle 0xf540
movq 0x20(%r14), %rbx
movq 0x28(%r14), %r15
xorl %r14d, %r14d
movq 0x8(%rsp), %rax
movq (%rax,%r14,8), %rsi
movq 0x10(%rsp), %rdi
callq 0x147c9
testq %rbx, %rbx
je 0xf502
movq (%rbx,%r14,8), %rdi
testq %rdi, %rdi
je 0xf4fb
movq (%rdi), %r13
testq %r13, %r13
je 0xf4fd
movq 0x28(%r13), %r12
movq 0x8(%r13), %rax
movq 0x18(%r13), %rdi
movl (%rax), %esi
callq 0x161f7
movq %r13, %rdi
callq 0x1030
movq %r12, %r13
testq %r12, %r12
jne 0xf4d2
movq (%rbx,%r14,8), %rdi
jmp 0xf4fd
xorl %edi, %edi
callq 0x1030
testq %r15, %r15
je 0xf52d
movq (%r15,%r14,8), %r13
testq %r13, %r13
je 0xf52d
movq (%r13), %rdi
movq 0x8(%r13), %r12
callq 0x1030
movq %r13, %rdi
callq 0x1030
movq %r12, %r13
testq %r12, %r12
jne 0xf510
incq %r14
cmpq %rbp, %r14
jne 0xf4a9
leaq 0x50(%rsp), %r14
jmp 0xf548
movq 0x20(%r14), %rbx
movq 0x28(%r14), %r15
movq 0x10(%r14), %rdi
callq 0x1030
movq 0x8(%r14), %rdi
callq 0x1030
movq 0x8(%rsp), %rdi
callq 0x1030
movq %r15, %rdi
callq 0x1030
testq %rbx, %rbx
je 0xf587
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1030
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/localEasySubtreeIsomorphism.c
// Function: isProbabilisticLocalSampleSubtree
char isProbabilisticLocalSampleSubtree(struct Graph* g, struct Graph* h, int nLocalTrees, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	struct BlockTree blockTree = getBlockTreeT(g, sgp);
	struct SpanningtreeTree sptTree = getSampledSpanningtreeTree(blockTree, nLocalTrees, 1, gp, sgp);

	char result = subtreeCheckForSpanningtreeTree(&sptTree, h, gp);

	dumpSpanningtreeTree(sptTree, gp);

	return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movq %r8, %r14
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %rsi
leaq 0x40(%rsp), %r12
movq %r12, %rdi
movq %r8, %rdx
callq 0xe7b8
movq 0x20(%r12), %rax
movq %rax, 0x20(%rsp)
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0x68(%rsp), %r12
movq %r12, %rdi
movl %ebp, %esi
movl $0x1, %edx
movq %rbx, %rcx
movq %r14, %r8
callq 0xefc8
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0xfa92
movl %eax, %ebp
movq 0x30(%r12), %rax
movq %rax, 0x30(%rsp)
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups 0x20(%r12), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0xf470
movl %ebp, %eax
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/localEasySubtreeIsomorphism.c
// Function: isLocalEasySubtree
char isLocalEasySubtree(struct Graph* g, struct Graph* h, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	struct BlockTree blockTree = getBlockTreeT(g, sgp);
	struct SpanningtreeTree sptTree = getFullSpanningtreeTree(blockTree, gp, sgp);

	char result = subtreeCheckForSpanningtreeTree(&sptTree, h, gp);

	dumpSpanningtreeTree(sptTree, gp);

	return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0xa0, %rsp
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %rsi
leaq 0x40(%rsp), %r12
movq %r12, %rdi
movq %rcx, %rdx
callq 0xe7b8
movq 0x20(%r12), %rax
movq %rax, 0x20(%rsp)
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0x68(%rsp), %r12
movq %r12, %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0xf24e
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0xfa92
movl %eax, %ebp
movq 0x30(%r12), %rax
movq %rax, 0x30(%rsp)
movups (%r12), %xmm0
movups 0x10(%r12), %xmm1
movups 0x20(%r12), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0xf470
movl %ebp, %eax
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/localEasySubtreeIsomorphism.c
// Function: spanningTreeCombinations
struct ShallowGraph* spanningTreeCombinations(struct ShallowGraph** lists, int currentPos, int nLists, struct ShallowGraphPool* sgp) {

	struct ShallowGraph* resultList = NULL;

	if (currentPos == nLists-1) {
		for (struct ShallowGraph* g=lists[currentPos]; g!=NULL; g=g->next) {
			struct ShallowGraph* tmp = cloneShallowGraph(g, sgp);
			tmp->next = resultList;
			resultList = tmp;
		}
	} else {
		struct ShallowGraph* conquered = spanningTreeCombinations(lists, currentPos + 1, nLists, sgp);
		for (struct ShallowGraph* g=lists[currentPos]; g!=NULL; g=g->next) {
			for (struct ShallowGraph* h=conquered; h!=NULL; h=h->next) {
				struct ShallowGraph* tmp1 = cloneShallowGraph(g, sgp);
				struct ShallowGraph* tmp2 = cloneShallowGraph(h, sgp);
				mergeTwoShallowGraphs(tmp1, tmp2, sgp);
				tmp1->next = resultList;
				resultList = tmp1;
			}
		}
		// the result of the recursive invocation is now useless
		dumpShallowGraphCycle(sgp, conquered);
	}
	return resultList;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movl %esi, %r12d
movq %rdi, %r14
leal -0x1(%rdx), %eax
cmpl %esi, %eax
jne 0xfefd
movslq %r12d, %rax
movq (%r14,%rax,8), %r15
testq %r15, %r15
je 0xff96
xorl %r12d, %r12d
movq %r15, %rdi
movq %rbx, %rsi
callq 0x8872
movq %rax, %r14
movq %r12, 0x18(%rax)
movq 0x18(%r15), %r15
movq %rax, %r12
testq %r15, %r15
jne 0xfeda
jmp 0xff99
leal 0x1(%r12), %esi
movq %r14, %rdi
movq %rbx, %rcx
callq 0xfeac
movq %rax, %r15
movslq %r12d, %rax
movq (%r14,%rax,8), %r12
xorl %r14d, %r14d
testq %r12, %r12
je 0xff89
movq %r15, %r13
testq %r15, %r15
je 0xff82
movq %r12, %rdi
movq %rbx, %rsi
callq 0x8872
movq %rax, %rbp
movq %r13, %rdi
movq %rbx, %rsi
callq 0x8872
movq (%rax), %rcx
movq 0x8(%rbp), %rdx
movq %rcx, 0x8(%rdx)
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rbp)
movl 0x10(%rax), %ecx
addl %ecx, 0x10(%rbp)
movq $0x0, 0x18(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x149f4
movq %r14, 0x18(%rbp)
movq 0x18(%r13), %r13
movq %rbp, %r14
testq %r13, %r13
jne 0xff27
movq 0x18(%r12), %r12
jmp 0xff1a
movq %rbx, %rdi
movq %r15, %rsi
callq 0x14a56
jmp 0xff99
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/localEasySubtreeIsomorphism.c
// Function: getNumberOfDifferentSpanningForestComponentsForKSamples
int getNumberOfDifferentSpanningForestComponentsForKSamples(struct Graph* g, int k, struct GraphPool* gp, struct ShallowGraphPool* sgp) {

	// sample k spanning trees
	struct ShallowGraph* sample = runForEachConnectedComponent(&xsampleSpanningTreesUsingWilson, g, k, k, 1, gp, sgp);

	// filter out, and count the spanning trees of singleton vertices, which are empty edge lists. (otherwise boom)
	// there are exactly k duplicate empty spanning trees per singleton
	int numberOfSingletons;
	sample = filterSingletonSpanningTrees(&numberOfSingletons, sample, sgp);
	int numberOfDifferentSpanningTreeComponents = numberOfSingletons / k;

	// filter out duplicate spanning trees and count remaining ones.
	sample = filterDuplicateSpanningTrees(sample, sgp);
	for (struct ShallowGraph* t=sample; t!=NULL; t=t->next) {
		++numberOfDifferentSpanningTreeComponents;
	}

	// avoid memory leaks, access to freed memory, and free unused stuff
	dumpShallowGraphCycle(sgp, sample);

	return numberOfDifferentSpanningTreeComponents;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r9
movl %esi, %ebp
movq %rdi, %rsi
movslq %ebp, %rcx
movq %rbx, (%rsp)
leaq 0x9a6f(%rip), %rdi      # 0x1a306
movl %ecx, %edx
movl $0x1, %r8d
callq 0x1a8de
xorl %r14d, %r14d
testq %rax, %rax
je 0x108da
xorl %r15d, %r15d
xorl %esi, %esi
cmpl $0x0, 0x10(%rax)
je 0x108bf
movq %r15, %rcx
movq %rax, %r15
jmp 0x108c8
incl %r14d
movq %rsi, %rcx
movq %rax, %rsi
movq 0x18(%rax), %rdx
movq %rcx, 0x18(%rax)
movq %rdx, %rax
testq %rdx, %rdx
jne 0x108b1
jmp 0x108df
xorl %esi, %esi
xorl %r15d, %r15d
movq %rbx, %rdi
callq 0x14a56
movl %r14d, %eax
cltd
idivl %ebp
movl %eax, %ebp
movq %r15, %rdi
movq %rbx, %rsi
callq 0xee4d
testq %rax, %rax
je 0x1090d
movq %rax, %rcx
incl %ebp
movq 0x18(%rcx), %rcx
testq %rcx, %rcx
jne 0x10902
movq %rbx, %rdi
movq %rax, %rsi
callq 0x14a56
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/lwm_embeddingOperators.c
// Function: stupidPatternEvaluation
void stupidPatternEvaluation(struct Graph** db, int nGraphs, struct Graph** patterns, int nPatterns, struct Vertex** pointers, struct GraphPool* gp) {
	int i;
	for (i=0; i<nGraphs; ++i) {
		int j;
		for (j=0; j<nPatterns; ++j) {
			if (isSubtree(db[i], patterns[j], gp)) {
				++pointers[j]->visited;
			}
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, 0x10(%rsp)
movl %ecx, 0x4(%rsp)
testl %esi, %esi
jle 0x10996
movq %r9, %rbx
movq %rdx, %r15
movq %rdi, %r12
movl %esi, %eax
movq %rax, 0x8(%rsp)
movl 0x4(%rsp), %ebp
xorl %r13d, %r13d
cmpl $0x0, 0x4(%rsp)
jle 0x1098c
xorl %r14d, %r14d
movq (%r12,%r13,8), %rdi
movq (%r15,%r14,8), %rsi
movq %rbx, %rdx
callq 0xabef
testb %al, %al
je 0x10984
movq 0x10(%rsp), %rax
movq (%rax,%r14,8), %rax
incl 0x1c(%rax)
incq %r14
cmpq %r14, %rbp
jne 0x10964
incq %r13
cmpq 0x8(%rsp), %r13
jne 0x1095a
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/lwm_embeddingOperators.c
// Function: subtreeRelimpOperator
struct SubtreeIsoDataStore subtreeRelimpOperator(struct SubtreeIsoDataStore data, struct Graph* h, double importance, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	(void)sgp; // unused
	struct SubtreeIsoDataStore result = data;
	result.h = h;
	result.S = NULL;
	result.foundIso = isImportantSubtreeRelative(result.g, result.h, importance, gp);
	return result;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movaps 0x10(%rsp), %xmm1
movaps 0x20(%rsp), %xmm2
movups %xmm2, 0x10(%rdi)
movups %xmm1, (%rdi)
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rdi)
movq %rsi, 0x10(%rdi)
movq $0x0, 0x18(%rdi)
movq 0x8(%rdi), %rdi
callq 0x98d8
movsbl %al, %eax
movl %eax, 0x20(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/lwm_embeddingOperators.c
// Function: subtreeAbsimpOperator
struct SubtreeIsoDataStore subtreeAbsimpOperator(struct SubtreeIsoDataStore data, struct Graph* h, double importance, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	(void)sgp; // unused
	struct SubtreeIsoDataStore result = data;
	result.h = h;
	result.S = NULL;
	result.foundIso = isImportantSubtreeAbsolute(result.g, result.h, importance, gp);
	return result;
}

// Assembly:
pushq %rbx
movq %rdx, %rcx
movq %rdi, %rbx
movaps 0x10(%rsp), %xmm1
movaps 0x20(%rsp), %xmm2
movups %xmm2, 0x10(%rdi)
movups %xmm1, (%rdi)
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rdi)
movq %rsi, 0x10(%rdi)
movq $0x0, 0x18(%rdi)
movq 0x8(%rdi), %rdi
cvttsd2si %xmm0, %edx
callq 0x98c6
movsbl %al, %eax
movl %eax, 0x20(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/lwm_embeddingOperators.c
// Function: hopsSimpleOperator
struct SubtreeIsoDataStore hopsSimpleOperator(struct SubtreeIsoDataStore data, struct Graph* h, double importance, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	(void)gp; // unused
	(void)sgp; // unused

	struct SubtreeIsoDataStore result = {0};
	result.g = data.g;
	result.h = h;

	for (int i=0; i<importance; ++i) {
		result.foundIso = subtreeIsomorphismSampler(data.g, h);
		if (result.foundIso) {
			break;
		}
	}

	return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorpd %xmm1, %xmm1
movupd %xmm1, 0x10(%rdi)
movupd %xmm1, (%rdi)
movq $0x0, 0x20(%rdi)
movq 0x38(%rsp), %r15
movq %r15, 0x8(%rdi)
movq %rsi, 0x10(%rdi)
xorpd %xmm1, %xmm1
movsd %xmm0, (%rsp)
ucomisd %xmm1, %xmm0
jbe 0x10beb
movq %rsi, %r14
movl $0x1, %ebp
movq %r15, %rdi
movq %r14, %rsi
callq 0x1be45
testb %al, %al
jne 0x10be5
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
incl %ebp
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm1
ja 0x10bc2
movsbl %al, %eax
movl %eax, 0x20(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/lwm_embeddingOperators.c
// Function: hopsSimplerandomOperator
struct SubtreeIsoDataStore hopsSimplerandomOperator(struct SubtreeIsoDataStore data, struct Graph* h, double importance, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	(void)gp; // unused
	(void)sgp; // unused

	struct SubtreeIsoDataStore result = {0};
	result.g = data.g;
	result.h = h;

	for (int i=0; i<importance; ++i) {
		result.foundIso = subtreeIsomorphismSamplerWithImageShuffling(data.g, h);
		if (result.foundIso) {
			break;
		}
	}

	return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorpd %xmm1, %xmm1
movupd %xmm1, 0x10(%rdi)
movupd %xmm1, (%rdi)
movq $0x0, 0x20(%rdi)
movq 0x38(%rsp), %r15
movq %r15, 0x8(%rdi)
movq %rsi, 0x10(%rdi)
xorpd %xmm1, %xmm1
movsd %xmm0, (%rsp)
ucomisd %xmm1, %xmm0
jbe 0x10c65
movq %rsi, %r14
movl $0x1, %ebp
movq %r15, %rdi
movq %r14, %rsi
callq 0x1c060
testb %al, %al
jne 0x10c5f
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
incl %ebp
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm1
ja 0x10c3c
movsbl %al, %eax
movl %eax, 0x20(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/lwm_embeddingOperators.c
// Function: hopsSimplematchingOperator
struct SubtreeIsoDataStore hopsSimplematchingOperator(struct SubtreeIsoDataStore data, struct Graph* h, double importance, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	(void)sgp; // unused

	struct SubtreeIsoDataStore result = {0};
	result.g = data.g;
	result.h = h;

	for (int i=0; i<importance; ++i) {
		result.foundIso = subtreeIsomorphismSamplerWithProperMatching(data.g, h, gp);
		if (result.foundIso) {
			break;
		}
	}

	return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorpd %xmm1, %xmm1
movupd %xmm1, 0x10(%rdi)
movupd %xmm1, (%rdi)
movq $0x0, 0x20(%rdi)
movq 0x48(%rsp), %r12
movq %r12, 0x8(%rdi)
movq %rsi, 0x10(%rdi)
xorpd %xmm1, %xmm1
movsd %xmm0, 0x8(%rsp)
ucomisd %xmm1, %xmm0
jbe 0x10cec
movq %rdx, %r14
movq %rsi, %r15
movl $0x1, %ebp
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1c290
testb %al, %al
jne 0x10ce6
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
incl %ebp
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
ja 0x10cbf
movsbl %al, %eax
movl %eax, 0x20(%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/lwm_embeddingOperators.c
// Function: hopsOperator
struct SubtreeIsoDataStore hopsOperator(struct SubtreeIsoDataStore data, struct Graph* h, double importance, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	(void)sgp; // unused

	struct SubtreeIsoDataStore result = {0};
	result.g = data.g;
	result.h = h;

	for (int i=0; i<importance; ++i) {
		result.foundIso = subtreeIsomorphismSamplerWithSampledMaximumMatching(data.g, h, gp, 0);
		if (result.foundIso) {
			break;
		}
	}

	return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x10, %rsp
movq %rdi, %rbx
xorpd %xmm1, %xmm1
movupd %xmm1, 0x10(%rdi)
movupd %xmm1, (%rdi)
movq $0x0, 0x20(%rdi)
movq 0x48(%rsp), %r12
movq %r12, 0x8(%rdi)
movq %rsi, 0x10(%rdi)
xorpd %xmm1, %xmm1
movsd %xmm0, 0x8(%rsp)
ucomisd %xmm1, %xmm0
jbe 0x10d76
movq %rdx, %r14
movq %rsi, %r15
movl $0x1, %ebp
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x1c5f5
testl %eax, %eax
jne 0x10d73
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
incl %ebp
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
ja 0x10d48
xorl %eax, %eax
movl %eax, 0x20(%rbx)
movq %rbx, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/lwm_embeddingOperators.c
// Function: hopsOperatorEstimate
struct SubtreeIsoDataStore hopsOperatorEstimate(struct SubtreeIsoDataStore data, struct Graph* h, double importance, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	(void)sgp; // unused

	struct SubtreeIsoDataStore result = {0};
	result.g = data.g;
	result.h = h;
	int estimate = 0;

	for (int i=0; i<importance; ++i) {
		estimate += subtreeIsomorphismSamplerWithSampledMaximumMatching(data.g, h, gp, 1);
		if (estimate < 0) {
			// int overflow
			result.foundIso = INT_MAX;
			fprintf(stderr, "Int overflow while computing average support estimate for graph %i for iteration %i (return support INT_MAX)\n", result.g->number, i);
			break;
		}
	}

	result.foundIso = ceil(estimate / importance);
	if (result.foundIso < inGraphThreshold) {
		result.foundIso = 0;
	}

	return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
xorpd %xmm1, %xmm1
movupd %xmm1, 0x10(%rdi)
movupd %xmm1, (%rdi)
movq $0x0, 0x20(%rdi)
movq 0x58(%rsp), %r12
movq %r12, 0x8(%rdi)
movq %rdi, 0x10(%rsp)
movq %rsi, 0x10(%rdi)
xorl %ebp, %ebp
xorpd %xmm1, %xmm1
movsd %xmm0, 0x8(%rsp)
ucomisd %xmm1, %xmm0
jbe 0x10e13
movq %rdx, %r14
movq %rsi, %r15
xorl %r13d, %r13d
xorl %ebp, %ebp
movl %ebp, %ebx
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl $0x1, %ecx
callq 0x1c5f5
movl %eax, %ebp
addl %ebx, %ebp
js 0x10e60
incl %r13d
xorps %xmm0, %xmm0
cvtsi2sd %r13d, %xmm0
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
ja 0x10de1
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
divsd 0x8(%rsp), %xmm0
callq 0x1240
cvttsd2si %xmm0, %eax
cvttpd2dq %xmm0, %xmm0
cvtdq2pd %xmm0, %xmm0
movq 0x10(%rsp), %rcx
movl %eax, 0x20(%rcx)
movq %rcx, %rax
movsd 0x1c314(%rip), %xmm1    # 0x2d158
ucomisd %xmm0, %xmm1
jbe 0x10e51
movl $0x0, 0x20(%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x1c191(%rip), %rax     # 0x2cff8
movq (%rax), %rdi
movl 0x8(%r12), %edx
leaq 0xfa58(%rip), %rsi      # 0x208ce
movl %r13d, %ecx
xorl %eax, %eax
callq 0x1160
jmp 0x10e13
nop
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/lwm_initAndCollect.c
// Function: getDB
int getDB(struct Graph*** db) {
	struct Graph* g = NULL;
	int dbSize = 0;
	int i = 0;

	while ((g = iterateFile())) {
		/* make space for storing graphs in array */
		if (dbSize <= i) {
			dbSize = dbSize == 0 ? 128 : dbSize * 2;
			*db = realloc(*db, dbSize * sizeof (struct Graph*));
		}
		/* store graph */
		(*db)[i] = g;
		++i;
	}
	return i;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorl %r14d, %r14d
xorl %eax, %eax
callq 0xd2be
testq %rax, %rax
je 0x10ef0
movq %rax, %r15
movl $0x80, %ebp
xorl %r14d, %r14d
xorl %r12d, %r12d
movslq %r12d, %rcx
movq (%rbx), %rax
cmpq %rcx, %r14
jl 0x10eda
leal (%r12,%r12), %r13d
testl %r12d, %r12d
cmovel %ebp, %r13d
movslq %r13d, %rsi
shlq $0x3, %rsi
movq %rax, %rdi
callq 0x11c0
movq %rax, (%rbx)
movl %r13d, %r12d
movq %r15, (%rax,%r14,8)
incq %r14
xorl %eax, %eax
callq 0xd2be
movq %rax, %r15
testq %rax, %rax
jne 0x10eaf
movl %r14d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/lwm_initAndCollect.c
// Function: getSpanningTreeSamplesOfDB
int getSpanningTreeSamplesOfDB(struct Graph*** db, int k, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	struct Graph* g = NULL;
	int dbSize = 0;
	int i = 0;

	while ((g = iterateFile())) {
		struct Graph* h = NULL;
		if (g->n < 2) {
			h = cloneGraph(g, gp);
		} else {
			// sample k spanning trees, canonicalize them and add them in a search tree (to avoid duplicates, i.e. isomorphic spanning trees)
			struct ShallowGraph* sample = runForEachConnectedComponent(&xsampleSpanningTreesUsingWilson, g, k, k, 1, gp, sgp);
			for (struct ShallowGraph* tree=sample; tree!=NULL; tree=tree->next) {
				if (tree->m != 0) {
					struct Graph* tmp = shallowGraphToGraph(tree, gp);
					tmp->next = h;
					h = tmp;
				}
			}
			dumpShallowGraphCycle(sgp, sample);
		}

		h = mergeGraphs(h, gp);
		h->number = g->number;
		h->activity = g->activity;

		// avoid memory leaks, access to freed memory, and free unused stuff
		hardCopyGraphLabels(h);
		dumpGraph(gp, g);

		/* make space for storing graphs in array */
		if (dbSize <= i) {
			dbSize = dbSize == 0 ? 128 : dbSize * 2;
			*db = realloc(*db, dbSize * sizeof (struct Graph*));
		}
		/* store graph */
		(*db)[i] = h;
		++i;
	}

	return i;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %r13
movq %rdx, %r14
movl %esi, %ebx
movq %rdi, %r15
xorl %r12d, %r12d
xorl %eax, %eax
callq 0xd2be
testq %rax, %rax
je 0x11049
movq %rax, %rbp
movslq %ebx, %rax
movq %rax, 0x10(%rsp)
xorl %r12d, %r12d
movq $0x0, 0x8(%rsp)
movq %r13, 0x20(%rsp)
movq %r15, 0x18(%rsp)
cmpl $0x1, (%rbp)
jg 0x10f65
movq %rbp, %rdi
movq %r14, %rsi
callq 0x7fc9
movq %rax, %rbx
jmp 0x10fd0
movq %r13, (%rsp)
leaq 0x9396(%rip), %rdi      # 0x1a306
movq %rbp, %rsi
movq 0x10(%rsp), %rcx
movl %ecx, %edx
movl $0x1, %r8d
movq %r14, %r9
callq 0x1a8de
movq %rax, %r15
testq %rax, %rax
je 0x10fb9
movq %r15, %r13
xorl %ebx, %ebx
cmpl $0x0, 0x10(%r13)
je 0x10fae
movq %r13, %rdi
movq %r14, %rsi
callq 0x8250
movq %rbx, 0x18(%rax)
movq %rax, %rbx
movq 0x18(%r13), %r13
testq %r13, %r13
jne 0x10f95
jmp 0x10fbb
xorl %ebx, %ebx
movq 0x20(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x14a56
movq 0x18(%rsp), %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7d8b
movq %rax, %rbx
movq 0x8(%rbp), %rax
movq %rax, 0x8(%rbx)
movq %rbx, %rdi
callq 0x1105b
movq %r14, %rdi
movq %rbp, %rsi
callq 0x14700
movq 0x8(%rsp), %rdx
movslq %edx, %rcx
movq (%r15), %rax
cmpq %rcx, %r12
jl 0x1102f
leal (%rdx,%rdx), %ebp
testl %edx, %edx
movl $0x80, %ecx
cmovel %ecx, %ebp
movslq %ebp, %rsi
shlq $0x3, %rsi
movq %rax, %rdi
callq 0x11c0
movq %rax, (%r15)
movl %ebp, %ecx
movq %rcx, 0x8(%rsp)
movq %rbx, (%rax,%r12,8)
incq %r12
xorl %eax, %eax
callq 0xd2be
movq %rax, %rbp
testq %rax, %rax
jne 0x10f4f
movl %r12d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/lwm_initAndCollect.c
// Function: hardCopyGraphLabels
static void hardCopyGraphLabels(struct Graph* g) {
	for (int vi=0; vi<g->n; ++vi) {
		struct Vertex* v = g->vertices[vi];
		if (v->isStringMaster == 0) {
			v->label = copyString(v->label);
			v->isStringMaster = 1;
		}
		for (struct VertexList* e=v->neighborhood; e!=NULL; e=e->next) {
			if (e->isStringMaster == 0) {
				e->label = copyString(e->label);
				e->isStringMaster = 1;
			}
		}
	}
}

// Assembly:
cmpl $0x0, (%rdi)
jle 0x110c2
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
movq 0x10(%rbx), %rax
movq (%rax,%r14,8), %r15
cmpl $0x0, 0x24(%r15)
jne 0x110a9
movq (%r15), %rdi
callq 0x14a88
movq %rax, (%r15)
movl $0x1, 0x24(%r15)
jmp 0x110a9
cmpl $0x0, 0x28(%r15)
jne 0x110a9
movq (%r15), %rdi
callq 0x14a88
movq %rax, (%r15)
movl $0x1, 0x28(%r15)
movq 0x8(%r15), %r15
testq %r15, %r15
jne 0x1108f
incq %r14
movslq (%rbx), %rax
cmpq %rax, %r14
jl 0x1106b
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/lwm_initAndCollect.c
// Function: getDBfromCanonicalStrings
int getDBfromCanonicalStrings(struct Graph*** db, FILE* stream, size_t bufferSize, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	int dbSize = 0;
	int i = 0;
	int graphId = -1;
	int graphCount = -1;
	char* buffer = malloc(bufferSize * sizeof(char));

	while (fscanf(stream, "%i\t%i\t", &graphCount, &graphId) == 2) {
		struct ShallowGraph* g = parseCString(stream, buffer, sgp);
		/* make space for storing graphs in array */
		if (dbSize <= i) {
			dbSize = dbSize == 0 ? 128 : dbSize * 2;
			*db = realloc(*db, dbSize * sizeof (struct Graph*));
		}
		/* store graph */
		(*db)[i] = treeCanonicalString2Graph(g, gp);
		(*db)[i]->number = graphId;
		(*db)[i]->activity = graphCount;
		hardCopyGraphLabels((*db)[i]);
		dumpShallowGraph(sgp, g);
		++i;
	}
	free(buffer);
	return i;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %rbx
movq %rcx, 0x20(%rsp)
movq %rsi, %r12
movq %rdi, %r13
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
leaq 0x4(%rsp), %r15
movl %eax, (%r15)
movq %rsp, %r14
movl %eax, (%r14)
movq %rdx, %rdi
callq 0x1190
movq %rax, 0x10(%rsp)
leaq 0xf836(%rip), %rsi      # 0x2093c
xorl %ebp, %ebp
movq %r12, %rdi
movq %r14, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x1060
cmpl $0x2, %eax
jne 0x111e7
movq %r13, 0x8(%rsp)
xorl %ebp, %ebp
xorl %r13d, %r13d
movq %r12, 0x18(%rsp)
movq %r12, %rdi
movq 0x10(%rsp), %rsi
movq %rbx, %rdx
callq 0x722f
movq %rax, %r14
movslq %r13d, %rax
cmpq %rax, %rbp
jge 0x11152
movq 0x8(%rsp), %r15
jmp 0x1118a
movq %rbx, %r12
leal (,%r13,2), %ebx
testl %r13d, %r13d
movl $0x80, %eax
cmovel %eax, %ebx
movq 0x8(%rsp), %r15
movq (%r15), %rdi
movslq %ebx, %rsi
shlq $0x3, %rsi
callq 0x11c0
movq %rax, (%r15)
movl %ebx, %r13d
movq %r12, %rbx
movq 0x18(%rsp), %r12
movq %r14, %rdi
movq 0x20(%rsp), %rsi
callq 0x7a80
movq (%r15), %rcx
movq %rax, (%rcx,%rbp,8)
movl 0x4(%rsp), %eax
movq (%r15), %rcx
movq (%rcx,%rbp,8), %rdi
movl %eax, 0x8(%rdi)
movl (%rsp), %eax
movl %eax, 0xc(%rdi)
callq 0x1105b
movq %rbx, %rdi
movq %r14, %rsi
callq 0x149f4
incq %rbp
movq %r12, %rdi
leaq 0xf76d(%rip), %rsi      # 0x2093c
movq %rsp, %rdx
leaq 0x4(%rsp), %rcx
xorl %eax, %eax
callq 0x1060
cmpl $0x2, %eax
je 0x11130
movq 0x10(%rsp), %rdi
callq 0x1030
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/lwm_initAndCollect.c
// Function: getPostorders
static int** getPostorders(struct Graph** db, int nGraphs) {
	int** postorderDB = malloc(nGraphs * sizeof(int*));
	for (int g=0; g<nGraphs; ++g) {
		postorderDB[g] = getPostorder(db[g], 0);
	}
	return postorderDB;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movslq %esi, %r15
leaq (,%r15,8), %rdi
callq 0x1190
movq %rax, %r14
testl %r15d, %r15d
jle 0x116dc
movl %ebp, %r15d
xorl %r12d, %r12d
movq (%rbx,%r12,8), %rdi
xorl %esi, %esi
callq 0x1bc66
movq %rax, (%r14,%r12,8)
incq %r12
cmpq %r12, %r15
jne 0x116c5
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/lwm_initAndCollect.c
// Function: createSingletonPatternSupportSetsForForestDB
static struct SupportSet* createSingletonPatternSupportSetsForForestDB(struct Graph** db, int** postorders, int nGraphs, struct Vertex* frequentVertices, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	(void)sgp; // unused
	// init levelwise search data structures for patterns with one vertex

	// data structures for iterative levelwise search
	struct SupportSet* vertexSupportSets = NULL;
	struct SupportSet* vertexSupportSetsTail = NULL;

	int id = 1;
	for (struct VertexList* e=frequentVertices->neighborhood; e!=NULL; e=e->next) {

		struct Graph* candidate = createGraph(1, gp);
		candidate->vertices[0]->label = e->label;
		e->endPoint->lowPoint = id;

		struct SupportSet* vertexSupport = getSupportSetOfVertex(db, postorders, nGraphs, candidate, id);

		if (vertexSupportSetsTail != NULL) {
			vertexSupportSetsTail->next = vertexSupport;
			vertexSupportSetsTail = vertexSupport;
		} else {
			vertexSupportSets = vertexSupport;
			vertexSupportSetsTail = vertexSupport;
		}
		++id;
	}
	return vertexSupportSets;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0xa8, %rsp
movq %r8, 0x38(%rsp)
movq %rsi, 0x50(%rsp)
movq 0x8(%rcx), %r13
testq %r13, %r13
je 0x11b5f
movq %rdi, %r15
movslq %edx, %rbp
movl $0x1, %r14d
leaq 0x90(%rsp), %r12
movq $0x0, 0x30(%rsp)
xorl %esi, %esi
movl %edx, 0x28(%rsp)
movq %rsi, 0x40(%rsp)
movl $0x1, %edi
movq 0x38(%rsp), %rsi
callq 0x85e3
movq %rax, %rbx
movq (%r13), %rax
movq 0x10(%rbx), %rcx
movq (%rcx), %rcx
movq %rax, (%rcx)
movq %r13, 0x48(%rsp)
movq 0x18(%r13), %rax
movl %r14d, 0x20(%rax)
xorl %eax, %eax
callq 0x1ce22
movq %rax, %r13
movl %r14d, 0x2c(%rsp)
movl %r14d, 0x8(%rbx)
cmpl $0x0, 0x28(%rsp)
je 0x11b22
xorl %r14d, %r14d
xorps %xmm0, %xmm0
movups %xmm0, (%r12)
movq $0x0, 0x10(%r12)
movq (%r15,%r14,8), %rax
movq %rax, 0x88(%rsp)
movq 0x50(%rsp), %rax
movq (%rax,%r14,8), %rax
movq %rax, 0x80(%rsp)
movq 0xa0(%rsp), %rax
movq %rax, 0x20(%rsp)
movups 0x80(%rsp), %xmm0
movups 0x90(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0x58(%rsp), %rdi
movq %rbx, %rsi
callq 0xa859
cmpl $0x0, 0x78(%rsp)
je 0x11b05
movq 0x78(%rsp), %rax
movq %rax, 0x20(%rsp)
movups 0x58(%rsp), %xmm0
movups 0x68(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %r13, %rdi
callq 0x1cc1f
jmp 0x11b16
movq 0x60(%rsp), %rax
movq 0x70(%rsp), %rdi
movl (%rax), %esi
callq 0x161f7
incq %r14
cmpq %r14, %rbp
jne 0x11a76
movq %r13, %rax
movq 0x40(%rsp), %rcx
testq %rcx, %rcx
je 0x11b38
movq %r13, 0x10(%rcx)
movq 0x30(%rsp), %rax
movl 0x2c(%rsp), %r14d
incl %r14d
movq 0x48(%rsp), %rcx
movq 0x8(%rcx), %rcx
movq %rax, 0x30(%rsp)
movq %r13, %rsi
movq %rcx, %r13
testq %rcx, %rcx
jne 0x11a23
jmp 0x11b61
xorl %eax, %eax
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/lwm_initAndCollect.c
// Function: createSingletonPatternSupportSetsForLocalEasyDB
static struct SupportSet* createSingletonPatternSupportSetsForLocalEasyDB(struct SpanningtreeTree* sptTrees, int nGraphs, struct Vertex* frequentVertices, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	(void)sgp; // unused
	// init levelwise search data structures for patterns with one vertex

	// data structures for iterative levelwise search
	struct SupportSet* vertexSupportSets = NULL;
	struct SupportSet* vertexSupportSetsTail = NULL;

	int id = 1;
	for (struct VertexList* e=frequentVertices->neighborhood; e!=NULL; e=e->next) {

		struct Graph* candidate = createGraph(1, gp);
		candidate->vertices[0]->label = e->label;
		e->endPoint->lowPoint = id;

		struct SupportSet* vertexSupport = initLocalEasyForVertices(sptTrees, nGraphs, candidate, id);

		if (vertexSupportSetsTail != NULL) {
			vertexSupportSetsTail->next = vertexSupport;
			vertexSupportSetsTail = vertexSupport;
		} else {
			vertexSupportSets = vertexSupport;
			vertexSupportSetsTail = vertexSupport;
		}
		++id;
	}
	return vertexSupportSets;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x88, %rsp
movq %rcx, 0x38(%rsp)
movq 0x8(%rdx), %r15
testq %r15, %r15
je 0x124a3
movl %esi, %ebx
movq %rdi, %r14
movslq %esi, %rax
movq %rax, 0x58(%rsp)
movl $0x1, %ebp
xorl %ecx, %ecx
xorl %edx, %edx
movl %esi, 0x28(%rsp)
movq %rdx, 0x48(%rsp)
movq %rcx, 0x40(%rsp)
movl $0x1, %edi
movq 0x38(%rsp), %rsi
callq 0x85e3
movq %rax, %r12
movq (%r15), %rax
movq 0x10(%r12), %rcx
movq (%rcx), %rcx
movq %rax, (%rcx)
movq %r15, 0x50(%rsp)
movq 0x18(%r15), %rax
movl %ebp, 0x20(%rax)
xorl %eax, %eax
callq 0x1ce22
movq %rax, 0x30(%rsp)
movl %ebp, 0x2c(%rsp)
movl %ebp, 0x8(%r12)
testl %ebx, %ebx
je 0x12467
xorl %ebx, %ebx
leaq 0x78(%rsp), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
imulq $0x38, %rbx, %rax
leaq (%r14,%rax), %rcx
movq (%r14,%rax), %r15
movq %r15, 0x68(%rsp)
movq %r12, 0x70(%rsp)
movq %rcx, 0x60(%rsp)
cmpl $0x0, (%r15)
jle 0x12459
movq 0x10(%r12), %rax
movq (%rax), %rax
movq (%rax), %r13
xorl %ebp, %ebp
movq 0x10(%r15), %rax
movq (%rax,%rbp,8), %rax
movq (%rax), %rdi
movq %r13, %rsi
callq 0x1bb34
testl %eax, %eax
je 0x12424
incq %rbp
movslq (%r15), %rax
cmpq %rax, %rbp
jl 0x12400
jmp 0x12459
movl $0x1, 0x80(%rsp)
movq 0x80(%rsp), %rax
movq %rax, 0x20(%rsp)
movups 0x60(%rsp), %xmm0
movups 0x70(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq 0x30(%rsp), %rdi
callq 0x1cc1f
incq %rbx
cmpq 0x58(%rsp), %rbx
jne 0x123c7
movq 0x30(%rsp), %rdx
movq %rdx, %rax
movq 0x48(%rsp), %rcx
testq %rcx, %rcx
je 0x12482
movq %rdx, 0x10(%rcx)
movq 0x40(%rsp), %rax
movl 0x2c(%rsp), %ebp
incl %ebp
movq 0x50(%rsp), %r15
movq 0x8(%r15), %r15
movq %rax, %rcx
testq %r15, %r15
movl 0x28(%rsp), %ebx
jne 0x12372
jmp 0x124a5
xorl %eax, %eax
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/lwm_initAndCollect.c
// Function: garbageCollectFrequentTreeMiningForForestDB
void garbageCollectFrequentTreeMiningForForestDB(void** y, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	struct IterativeBfsForForestsDataStructures* dataStructures = (struct IterativeBfsForForestsDataStructures*)y;

	dumpSearchTree(gp, dataStructures->initialFrequentPatterns);
	dumpShallowGraphCycle(sgp, dataStructures->extensionEdges);
	dumpGraph(gp, dataStructures->extensionEdgesVertexStore);

	for (int i=0; i<dataStructures->nGraphs; ++i) {
		dumpGraph(gp, dataStructures->db[i]);
		free(dataStructures->postorders[i]);
	}

	free(dataStructures->db);
	free(dataStructures->postorders);
	free(dataStructures);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rdi), %rsi
movq %r14, %rdi
callq 0x1b546
movq 0x18(%rbx), %rsi
movq %r15, %rdi
callq 0x14a56
movq 0x20(%rbx), %rsi
movq %r14, %rdi
callq 0x14700
cmpl $0x0, 0x28(%rbx)
jle 0x12743
xorl %r15d, %r15d
movq (%rbx), %rax
movq (%rax,%r15,8), %rsi
movq %r14, %rdi
callq 0x14700
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x1030
incq %r15
movslq 0x28(%rbx), %rax
cmpq %rax, %r15
jl 0x1271b
movq (%rbx), %rdi
callq 0x1030
movq 0x8(%rbx), %rdi
callq 0x1030
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/lwm_initAndCollect.c
// Function: garbageCollectLocalEasyForGraphDB
void garbageCollectLocalEasyForGraphDB(void** y, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	struct IterativeBfsForLocalEasyDataStructures* dataStructures = (struct IterativeBfsForLocalEasyDataStructures*)y;

	dumpSearchTree(gp, dataStructures->initialFrequentPatterns);
	dumpShallowGraphCycle(sgp, dataStructures->extensionEdges);
	dumpGraph(gp, dataStructures->extensionEdgesVertexStore);

	for (int i=0; i<dataStructures->nGraphs; ++i) {
		dumpGraph(gp, dataStructures->sptTrees[i].g);
		dumpSpanningtreeTree(dataStructures->sptTrees[i], gp);
	}

	free(dataStructures->sptTrees);
	free(dataStructures);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x38, %rsp
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0x8(%rdi), %rsi
movq %r14, %rdi
callq 0x1b546
movq 0x10(%rbx), %rsi
movq %r15, %rdi
callq 0x14a56
movq 0x18(%rbx), %rsi
movq %r14, %rdi
callq 0x14700
cmpl $0x0, 0x20(%rbx)
jle 0x127f8
xorl %r15d, %r15d
xorl %r12d, %r12d
movq (%rbx), %rax
movq (%rax,%r15), %rsi
movq %r14, %rdi
callq 0x14700
movq (%rbx), %rax
movq 0x30(%rax,%r15), %rcx
movq %rcx, 0x30(%rsp)
movups (%rax,%r15), %xmm0
movups 0x10(%rax,%r15), %xmm1
movups 0x20(%rax,%r15), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %r14, %rdi
callq 0xf470
incq %r12
movslq 0x20(%rbx), %rax
addq $0x38, %r15
cmpq %rax, %r12
jl 0x127a5
movq (%rbx), %rdi
callq 0x1030
movq %rbx, %rdi
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/lwm_initAndCollect.c
// Function: getSupportSetsOfVerticesForPatternEnumeration
struct SupportSet* getSupportSetsOfVerticesForPatternEnumeration(struct Graph** db, int nGraphs, struct Vertex* frequentVertices, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	(void)sgp; // unused
	// init levelwise search data structures for patterns with one vertex

	// data structures for iterative levelwise search
	struct SupportSet* vertexSupportSets = NULL;
	struct SupportSet* vertexSupportSetsTail = NULL;

	int id = 1;
	for (struct VertexList* e=frequentVertices->neighborhood; e!=NULL; e=e->next) {

		struct Graph* candidate = createGraph(1, gp);
		candidate->vertices[0]->label = e->label;
		e->endPoint->lowPoint = id;

		struct SupportSet* vertexSupport = initPatternEnumerationForVertices(db, nGraphs, candidate, id);

		if (vertexSupportSetsTail != NULL) {
			vertexSupportSetsTail->next = vertexSupport;
			vertexSupportSetsTail = vertexSupport;
		} else {
			vertexSupportSets = vertexSupport;
			vertexSupportSetsTail = vertexSupport;
		}
		++id;
	}
	return vertexSupportSets;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rcx, 0x38(%rsp)
movq 0x8(%rdx), %r15
testq %r15, %r15
je 0x12936
movq %rdi, %r14
movslq %esi, %rbx
movl $0x1, %r13d
leaq 0x68(%rsp), %rbp
movq $0x0, 0x30(%rsp)
xorl %edx, %edx
movl %esi, 0x28(%rsp)
movq %rdx, 0x40(%rsp)
movl $0x1, %edi
movq 0x38(%rsp), %rsi
callq 0x85e3
movq %rax, %r12
movq (%r15), %rax
movq 0x10(%r12), %rcx
movq (%rcx), %rcx
movq %rax, (%rcx)
movq %r15, 0x48(%rsp)
movq 0x18(%r15), %rax
movl %r13d, 0x20(%rax)
xorl %eax, %eax
callq 0x1ce22
movq %rax, %r15
movl %r13d, 0x2c(%rsp)
movl %r13d, 0x8(%r12)
cmpl $0x0, 0x28(%rsp)
xorps %xmm0, %xmm0
je 0x128f9
xorl %r13d, %r13d
movups %xmm0, (%rbp)
movq (%r14,%r13,8), %rax
movq %rax, 0x58(%rsp)
movq %r12, 0x60(%rsp)
movq $0x0, 0x50(%rsp)
movl $0x1, 0x70(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x20(%rsp)
movups 0x50(%rsp), %xmm0
movups 0x60(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %r15, %rdi
callq 0x1cc1f
xorps %xmm0, %xmm0
incq %r13
cmpq %r13, %rbx
jne 0x128a6
movq %r15, %rax
movq 0x40(%rsp), %rcx
testq %rcx, %rcx
je 0x1290f
movq %r15, 0x10(%rcx)
movq 0x30(%rsp), %rax
movl 0x2c(%rsp), %r13d
incl %r13d
movq 0x48(%rsp), %rcx
movq 0x8(%rcx), %rcx
movq %rax, 0x30(%rsp)
movq %r15, %rdx
movq %rcx, %r15
testq %rcx, %rcx
jne 0x12853
jmp 0x12938
xorl %eax, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/lwm_initAndCollect.c
// Function: garbageCollectPatternEnumeration
void garbageCollectPatternEnumeration(void** y, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	struct IterativeBfsForForestsDataStructures* dataStructures = (struct IterativeBfsForForestsDataStructures*)y;

	dumpSearchTree(gp, dataStructures->initialFrequentPatterns);
	dumpShallowGraphCycle(sgp, dataStructures->extensionEdges);
	dumpGraph(gp, dataStructures->extensionEdgesVertexStore);

	for (int i=0; i<dataStructures->nGraphs; ++i) {
		dumpGraph(gp, dataStructures->db[i]);
	}

	free(dataStructures->db);
	free(dataStructures);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rdi), %rsi
movq %r14, %rdi
callq 0x1b546
movq 0x18(%rbx), %rsi
movq %r15, %rdi
callq 0x14a56
movq 0x20(%rbx), %rsi
movq %r14, %rdi
callq 0x14700
cmpl $0x0, 0x28(%rbx)
jle 0x12ad2
xorl %r15d, %r15d
movq (%rbx), %rax
movq (%rax,%r15,8), %rsi
movq %r14, %rdi
callq 0x14700
incq %r15
movslq 0x28(%rbx), %rax
cmpq %rax, %r15
jl 0x12ab7
movq (%rbx), %rdi
callq 0x1030
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x1030
nop
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/lwm_miningAndExtension.c
// Function: getCandidateSupportSuperSet
struct SupportSet* getCandidateSupportSuperSet(struct IntSet* parentIds, struct SupportSet* previousLevelSupportLists, int parentIdToKeep) {
	assert(parentIds != NULL);
	assert(previousLevelSupportLists != NULL);
	assert(containsInt(parentIds, parentIdToKeep));

	// obtain support sets of parents
	struct SupportSet* parentSupportSets = getSupportSetsOfPatterns(previousLevelSupportLists, parentIds);

	// move desired parent support set to head of list to keep the correct subtreeIsoDataStores
	parentSupportSets = supportSetChangeHead(parentSupportSets, parentIdToKeep);

	// compute a candidate support set that is the intersection of the support sets of the apriori parents of the extension
	struct SupportSet* candidateSupportSuperSet = intersectSupportSets(parentSupportSets);

	// garbage collection
	while (parentSupportSets) {
		struct SupportSet* tmp = parentSupportSets->next;
		free(parentSupportSets);
		parentSupportSets = tmp;
	}

	return candidateSupportSuperSet;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movl %edx, %ebx
movq %rdi, %rax
movq %rsi, %rdi
movq %rax, %rsi
callq 0x1d09f
movq %rax, %rdi
movl %ebx, %esi
callq 0x1d15f
movq %rax, %r14
movq %rax, %rdi
callq 0x1d000
movq %rax, %rbx
testq %r14, %r14
je 0x12b2e
movq 0x10(%r14), %r15
movq %r14, %rdi
callq 0x1030
movq %r15, %r14
testq %r15, %r15
jne 0x12b1a
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq