LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/localEasySubtreeIsomorphism.c
// Function: compareVertexListsGeneric
int compareVertexListsGeneric(const struct VertexList* e1, const struct VertexList* e2, int (*compar)(const struct VertexList*, const struct VertexList*)) {

	/* if this value is larger than 0 the first label is lex. larger than the second etc. */
	int returnValue = compar(e1, e2);

	/* if the two paths are identical so far wrt. labels check the next vertex on each path */
	if (returnValue == 0) {

		if ((e1->next) && (e2->next)) {
			/* if both lists have a next, proceed recursively */
			return compareVertexListsGeneric(e1->next, e2->next, compar);
		} else {
			/* if the first list is shorter, its lex. smaller */
			if ((e1->next == NULL) && (e2->next)){
				return -1;
			}
			/* if the second is shorter, this one is lex.smaller */
			if ((e2->next == NULL) && (e1->next)){
				return 1;
			}
		}

		/* if none of the cases above was chosen, both paths end here and we have to return 0 as both strings
		represented by the lists are identical */
		return 0;

	} else {
		/* if the paths differ in the current vertices, we return the return value of the comparison function */
		return returnValue;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %r12
pushq $0x1
popq %rbx
movq %r12, %rdi
movq %r14, %rsi
callq *%r15
testl %eax, %eax
jne 0xc3c3
movq 0x8(%r12), %r12
movq 0x8(%r14), %r14
testq %r12, %r12
je 0xc3c7
testq %r14, %r14
jne 0xc3a1
jmp 0xc3ce
movl %eax, %ebx
jmp 0xc3ce
xorl %ebx, %ebx
negq %r14
sbbl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/localEasySubtreeIsomorphism.c
// Function: filterSortedSpanningTreeList
struct ShallowGraph* filterSortedSpanningTreeList(struct ShallowGraph* l, int (*compar)(struct ShallowGraph*, struct ShallowGraph*), struct ShallowGraphPool* sgp) {
	struct ShallowGraph* result = NULL;
	struct ShallowGraph* garbage = NULL;
	for (struct ShallowGraph* g=l; g!=NULL; /* increment is done below */) {
		if (g->next != NULL) {
			struct ShallowGraph* next = g->next;
			if (compar(g, g->next) == 0) {
				g->next = garbage;
				garbage = g;
			} else {
				g->next = result;
				result = g;
			}
			g = next;
		} else {
			// the last element should always be in the result.
			g->next = result;
			result = g;
			g = NULL;
		}
	}
	dumpShallowGraphCycle(sgp, garbage);
	return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
xorl %r14d, %r14d
xorl %r13d, %r13d
testq %r12, %r12
je 0xc466
movq 0x18(%r12), %rbp
testq %rbp, %rbp
je 0xc456
movq %r12, %rdi
movq %rbp, %rsi
callq *%r15
testl %eax, %eax
movq %r13, %rcx
cmoveq %r14, %rcx
cmoveq %r12, %r14
movq %r13, %rax
cmovneq %r12, %rax
movq %rcx, %r13
jmp 0xc459
movq %r12, %rax
movq %r13, 0x18(%r12)
movq %rbp, %r12
movq %rax, %r13
jmp 0xc425
movq %rbx, %rdi
movq %r14, %rsi
callq 0x11888
movq %r13, %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/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
subq $0x18, %rsp
movq %rsi, 0x10(%rsp)
movq %rdi, %r15
leaq -0x11e(%rip), %r12      # 0xc382
pushq $0x8
popq %r13
xorl %r14d, %r14d
movq %rdi, 0x8(%rsp)
testq %r15, %r15
je 0xc556
movslq 0x10(%r15), %rbx
cmpq $0x2, %rbx
jl 0xc54a
leaq (,%rbx,8), %rdi
callq 0x1180
movq %rax, %rbp
movq (%r15), %rax
movq %rax, (%rbp)
pushq $0x1
popq %rax
cmpq %rax, %rbx
je 0xc4f5
movq -0x8(%rbp,%rax,8), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, (%rbp,%rax,8)
incq %rax
jmp 0xc4dd
movq %rbp, %rdi
movq %rbx, %rsi
movq %r13, %rdx
movq %r12, %rcx
callq 0x1080
movslq 0x10(%r15), %rax
leal -0x1(%rax), %ecx
testl %ecx, %ecx
movl $0x0, %edx
cmovlel %edx, %ecx
xorl %edx, %edx
cmpq %rdx, %rcx
je 0xc531
movq (%rbp,%rdx,8), %rsi
movq 0x8(%rbp,%rdx,8), %rdi
incq %rdx
movq %rdi, 0x8(%rsi)
jmp 0xc519
movq -0x8(%rbp,%rax,8), %rax
andq $0x0, 0x8(%rax)
movq (%rbp), %rax
movq %rax, (%r15)
movq %rbp, %rdi
callq 0x1030
incq %r14
movq 0x18(%r15), %r15
jmp 0xc4ac
cmpq $0x2, %r14
jb 0xc594
leaq (,%r14,8), %rdi
callq 0x1180
movq %rax, %r12
movq 0x8(%rsp), %rax
movq %rax, (%r12)
pushq $0x1
popq %rax
movq 0x10(%rsp), %rbx
cmpq %rax, %r14
je 0xc5a0
movq -0x8(%r12,%rax,8), %rcx
movq 0x18(%rcx), %rcx
movq %rcx, (%r12,%rax,8)
incq %rax
jmp 0xc57d
movq 0x10(%rsp), %rbx
movq 0x8(%rsp), %r14
jmp 0xc5e5
leaq -0x1ae(%rip), %rcx      # 0xc3f9
pushq $0x8
popq %rdx
movq %r12, %rdi
movq %r14, %rsi
callq 0x1080
pushq $0x1
popq %rax
cmpq %rax, %r14
je 0xc5cf
movq -0x8(%r12,%rax,8), %rcx
movq (%r12,%rax,8), %rdx
movq %rdx, 0x18(%rcx)
incq %rax
jmp 0xc5b8
movq -0x8(%r12,%r14,8), %rax
andq $0x0, 0x18(%rax)
movq (%r12), %r14
movq %r12, %rdi
callq 0x1030
leaq -0x205(%rip), %rsi      # 0xc3e7
movq %r14, %rdi
movq %rbx, %rdx
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0xc40b
// File: /workspace/github_c_makefile_star2_O2/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 %rbx
movq %rsi, %r14
movq %rdi, %rbx
testq %rdi, %rdi
je 0xc7e0
movq 0x18(%rbx), %r15
andq $0x0, 0x18(%rbx)
testq %r15, %r15
jne 0xc7e6
xorl %eax, %eax
xorl %esi, %esi
jmp 0xc7f2
movq 0x18(%r15), %rax
andq $0x0, 0x18(%r15)
movq %r15, %rsi
testq %rsi, %rsi
je 0xc814
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rdx
callq 0xd46c
movl $0x0, %eax
movq %r15, %rsi
testq %r15, %r15
je 0xc7f2
jmp 0xc7e6
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xca20
leaq 0x40(%rsp), %rax
movl 0x30(%rax), %r15d
xorl %r12d, %r12d
testl %r15d, %r15d
cmovlel %r12d, %r15d
cmpq %r15, %r12
je 0xca20
movq (%r14,%r12,8), %r13
testq %r13, %r13
je 0xca1b
movq (%r13), %rbx
testq %rbx, %rbx
je 0xca0e
movq 0x28(%rbx), %rbp
movq 0x8(%rbx), %rax
movq 0x18(%rbx), %rdi
movl (%rax), %esi
callq 0x133ca
movq %rbx, %rdi
callq 0x1030
movq %rbp, %rbx
jmp 0xc9e9
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%r13)
movups %xmm0, (%r13)
incq %r12
jmp 0xc9d7
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/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), %rcx
movl 0x30(%rcx), %ebp
movq 0x18(%rcx), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rcx), %rbx
movq 0x28(%rcx), %r14
xorl %r15d, %r15d
testl %ebp, %ebp
cmovlel %r15d, %ebp
cmpq %rbp, %r15
je 0xcaf8
movq 0x8(%rsp), %rax
movq (%rax,%r15,8), %rsi
movq 0x10(%rsp), %rdi
callq 0x116ef
testq %rbx, %rbx
je 0xcac3
movq (%rbx,%r15,8), %rax
testq %rax, %rax
je 0xcabc
movq (%rax), %r13
testq %r13, %r13
je 0xcab6
movq 0x28(%r13), %r12
movq 0x8(%r13), %rax
movq 0x18(%r13), %rdi
movl (%rax), %esi
callq 0x133ca
movq %r13, %rdi
callq 0x1030
movq %r12, %r13
jmp 0xca91
movq (%rbx,%r15,8), %rdi
jmp 0xcabe
xorl %edi, %edi
callq 0x1030
testq %r14, %r14
je 0xcaf0
movq (%r14,%r15,8), %r13
testq %r13, %r13
je 0xcaf0
testq %r13, %r13
je 0xcaf0
movq (%r13), %rdi
movq 0x8(%r13), %r12
callq 0x1030
movq %r13, %rdi
callq 0x1030
movq %r12, %r13
jmp 0xcad1
incq %r15
jmp 0xca64
leaq 0x50(%rsp), %r15
movq 0x10(%r15), %rdi
callq 0x1030
movq 0x8(%r15), %rdi
callq 0x1030
movq 0x8(%rsp), %rdi
callq 0x1030
movq %r14, %rdi
callq 0x1030
movq %rbx, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/localEasySubtreeIsomorphism.c
// Function: printSptTree
void printSptTree(struct SpanningtreeTree sptTree) {
	printf("\nbase graph:\n");
	printGraph(sptTree.g);

	printf("\nnRoots: %i\n", sptTree.nRoots);
	printf("nNonTrivialRoots: %i\n", countNontrivialRoots(sptTree));

	printf("local spanning trees:\n");
	for (int v=0; v<sptTree.nRoots; ++v) {
		printf("root %i (-> %i): lps (%i %i) \n", sptTree.roots[v]->number, sptTree.parents[v]->number, sptTree.roots[v]->lowPoint, sptTree.parents[v]->lowPoint);
		printGraph(sptTree.localSpanningTrees[v]);
	}

	printf("Characteristics:\n");
	for (int v=0; v<sptTree.nRoots; ++v) {
		printf("root %i (-> %i):\n", sptTree.roots[v]->number, sptTree.parents[v]->number);
		if (sptTree.characteristics && sptTree.characteristics[v]) {
			for (struct SupportSetElement* e=sptTree.characteristics[v]->first; e!=NULL; e=e->next) {
				printNewCubeCondensed(e->data.S, e->data.g->n, e->data.h->n, stdout);
			}
		} else {
			printf("empty\n");
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
leaq 0x40(%rsp), %r13
leaq 0x10d11(%rip), %rdi     # 0x1d85f
callq 0x1070
movq (%r13), %rdi
callq 0x6949
movl 0x30(%r13), %ebx
leaq 0x10ca4(%rip), %rdi     # 0x1d80b
xorl %r14d, %r14d
movl %ebx, %esi
xorl %eax, %eax
callq 0x10b0
movq 0x18(%r13), %rbp
testl %ebx, %ebx
cmovlel %r14d, %ebx
xorl %esi, %esi
cmpq %r14, %rbx
je 0xcb96
movq (%rbp,%r14,8), %rax
cmpq $0x1, 0x18(%rax)
sbbl $-0x1, %esi
incq %r14
jmp 0xcb7f
leaq 0x10c7b(%rip), %rdi     # 0x1d818
xorl %eax, %eax
callq 0x10b0
leaq 0x10cc1(%rip), %rdi     # 0x1d86c
callq 0x1070
movq 0x8(%r13), %r12
movq 0x10(%r13), %rax
movq %rax, (%rsp)
leaq 0x10c6b(%rip), %r14     # 0x1d82e
xorl %r15d, %r15d
cmpq %r15, %rbx
je 0xcbfd
movq (%r12,%r15,8), %rax
movq (%rsp), %rcx
movq (%rcx,%r15,8), %rdi
movl 0x18(%rax), %esi
movl 0x20(%rax), %ecx
movl 0x18(%rdi), %edx
movl 0x20(%rdi), %r8d
movq %r14, %rdi
xorl %eax, %eax
callq 0x10b0
movq (%rbp,%r15,8), %rdi
callq 0x6949
incq %r15
jmp 0xcbc6
leaq 0x10c7e(%rip), %rdi     # 0x1d882
callq 0x1070
movq 0x20(%r13), %rbp
movq 0x1d3b4(%rip), %r15     # 0x29fc8
xorl %r14d, %r14d
cmpq %rbx, %r14
je 0xcc8c
movq %r12, %r13
movq (%r12,%r14,8), %rax
movl 0x18(%rax), %esi
movq (%rsp), %rax
movq (%rax,%r14,8), %rax
movl 0x18(%rax), %edx
leaq 0x10c15(%rip), %rdi     # 0x1d84d
xorl %eax, %eax
callq 0x10b0
testq %rbp, %rbp
je 0xcc78
movq (%rbp,%r14,8), %r12
testq %r12, %r12
je 0xcc78
movq (%r12), %r12
testq %r12, %r12
je 0xcc84
movq 0x18(%r12), %rdi
movq 0x8(%r12), %rax
movq 0x10(%r12), %rcx
movl (%rax), %esi
movl (%rcx), %edx
movq (%r15), %rcx
callq 0x13453
addq $0x28, %r12
jmp 0xcc4e
leaq 0x10c14(%rip), %rdi     # 0x1d893
callq 0x1070
incq %r14
movq %r13, %r12
jmp 0xcc17
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/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 0xbe98
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
pushq $0x1
popq %rdx
movq %r12, %rdi
movl %ebp, %esi
movq %rbx, %rcx
movq %r14, %r8
callq 0xc605
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0xcfbf
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 0xca2f
movl %ebp, %eax
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xbe98
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 0xc81d
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0xcfbf
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 0xca2f
movl %ebp, %eax
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0xd3e7
movslq %r12d, %rax
leaq (%r14,%rax,8), %r15
xorl %r14d, %r14d
movq (%r15), %r15
testq %r15, %r15
je 0xd45a
movq %r15, %rdi
movq %rbx, %rsi
callq 0x659e
movq %r14, 0x18(%rax)
addq $0x18, %r15
movq %rax, %r14
jmp 0xd3c3
leal 0x1(%r12), %esi
movq %r14, %rdi
movq %rbx, %rcx
callq 0xd39e
movq %rax, %r15
movslq %r12d, %rax
leaq (%r14,%rax,8), %r12
xorl %r14d, %r14d
movq (%r12), %r12
testq %r12, %r12
je 0xd44f
movq %r15, %r13
testq %r13, %r13
je 0xd449
movq %r12, %rdi
movq %rbx, %rsi
callq 0x659e
movq %rax, %rbp
movq %r13, %rdi
movq %rbx, %rsi
callq 0x659e
movq %rbp, %rdi
movq %rax, %rsi
movq %rbx, %rdx
callq 0xd46c
movq %r14, 0x18(%rbp)
movq 0x18(%r13), %r13
movq %rbp, %r14
jmp 0xd410
addq $0x18, %r12
jmp 0xd404
movq %rbx, %rdi
movq %r15, %rsi
callq 0x11888
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_O2/pwelke[P]GraphMiningTools/localEasySubtreeIsomorphism.c
// Function: mergeTwoShallowGraphs
static struct ShallowGraph* mergeTwoShallowGraphs(struct ShallowGraph* first, struct ShallowGraph* second, struct ShallowGraphPool* sgp) {
	first->lastEdge->next = second->edges;
	first->lastEdge = second->lastEdge;
	first->m += second->m;

	second->edges = second->lastEdge = NULL;
	second->next = NULL;
	dumpShallowGraph(sgp, second);
	return first;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rsi), %rax
movq 0x8(%rdi), %rcx
movq %rax, 0x8(%rcx)
movq 0x8(%rsi), %rax
movq %rax, 0x8(%rdi)
movl 0x10(%rsi), %eax
addl %eax, 0x10(%rdi)
andq $0x0, 0x18(%rsi)
movq %rdx, %rdi
xorps %xmm0, %xmm0
movups %xmm0, (%rsi)
callq 0x1184e
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x9f24(%rip), %rdi      # 0x17cbf
pushq $0x1
popq %r8
movl %ecx, %edx
callq 0x181c4
xorl %r14d, %r14d
xorl %esi, %esi
xorl %r15d, %r15d
testq %rax, %rax
je 0xddd7
cmpl $0x0, 0x10(%rax)
je 0xddc1
movq %r15, %rcx
movq %rax, %r15
jmp 0xddca
incl %r14d
movq %rsi, %rcx
movq %rax, %rsi
movq 0x18(%rax), %rdx
movq %rcx, 0x18(%rax)
movq %rdx, %rax
jmp 0xddae
movq %rbx, %rdi
callq 0x11888
movl %r14d, %eax
cltd
idivl %ebp
movl %eax, %ebp
movq %r15, %rdi
movq %rbx, %rsi
callq 0xc483
movq %rax, %rcx
testq %rcx, %rcx
je 0xde02
incl %ebp
movq 0x18(%rcx), %rcx
jmp 0xddf5
movq %rbx, %rdi
movq %rax, %rsi
callq 0x11888
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r9, %rbx
movq %r8, 0x10(%rsp)
movl %ecx, %r15d
movq %rdx, %r12
xorl %r13d, %r13d
testl %ecx, %ecx
cmovlel %r13d, %r15d
movq %rdi, %rbp
testl %esi, %esi
cmovlel %r13d, %esi
movq %rsi, 0x8(%rsp)
cmpq 0x8(%rsp), %r13
je 0xde95
xorl %r14d, %r14d
cmpq %r14, %r15
je 0xde90
movq (%rbp,%r13,8), %rdi
movq (%r12,%r14,8), %rsi
movq %rbx, %rdx
callq 0x86b2
testb %al, %al
je 0xde8b
movq 0x10(%rsp), %rax
movq (%rax,%r14,8), %rax
incl 0x1c(%rax)
incq %r14
jmp 0xde65
incq %r13
jmp 0xde5b
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/lwm_embeddingOperators.c
// Function: localEasySubtreeCheckOperatorWithResampling
struct SubtreeIsoDataStore localEasySubtreeCheckOperatorWithResampling(struct SubtreeIsoDataStore data, struct Graph* h, double importance, struct GraphPool* gp, struct ShallowGraphPool* sgp) {

	struct SubtreeIsoDataStore result = data;
	result.h = h;
	result.S = NULL;

	result.foundIso = isProbabilisticLocalSampleSubtree(result.g, result.h, (int)importance, gp, sgp);
	return result;
}

// Assembly:
pushq %rbx
movq %rcx, %r8
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)
andq $0x0, 0x18(%rdi)
movq 0x8(%rdi), %rdi
cvttsd2si %xmm0, %edx
callq 0xd239
movsbl %al, %eax
movl %eax, 0x20(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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)
andq $0x0, 0x18(%rdi)
movq 0x8(%rdi), %rdi
callq 0x7504
movsbl %al, %eax
movl %eax, 0x20(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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)
andq $0x0, 0x18(%rdi)
movq 0x8(%rdi), %rdi
cvttsd2si %xmm0, %edx
callq 0x74f2
movsbl %al, %eax
movl %eax, 0x20(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r12
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rsi, %r14
movq %rdi, %rbx
xorpd %xmm0, %xmm0
movupd %xmm0, 0x10(%rdi)
movupd %xmm0, (%rdi)
andq $0x0, 0x20(%rdi)
movq 0x48(%rsp), %r15
movq %r15, 0x8(%rdi)
movq %rsi, 0x10(%rdi)
xorl %ebp, %ebp
xorl %r12d, %r12d
cvtsi2sd %r12d, %xmm0
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0xe0d1
movq %r15, %rdi
movq %r14, %rsi
callq 0x1960c
incl %r12d
testb %al, %al
je 0xe0ab
movsbl %al, %ebp
movl %ebp, 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_O2/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 %r12
pushq %rbx
subq $0x10, %rsp
movsd %xmm0, 0x8(%rsp)
movq %rsi, %r14
movq %rdi, %rbx
xorpd %xmm0, %xmm0
movupd %xmm0, 0x10(%rdi)
movupd %xmm0, (%rdi)
andq $0x0, 0x20(%rdi)
movq 0x48(%rsp), %r15
movq %r15, 0x8(%rdi)
movq %rsi, 0x10(%rdi)
xorl %ebp, %ebp
xorl %r12d, %r12d
cvtsi2sd %r12d, %xmm0
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0xe146
movq %r15, %rdi
movq %r14, %rsi
callq 0x19811
incl %r12d
testb %al, %al
je 0xe120
movsbl %al, %ebp
movl %ebp, 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_O2/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movsd %xmm0, (%rsp)
movq %rsi, %r15
movq %rdi, %rbx
xorpd %xmm0, %xmm0
movupd %xmm0, 0x10(%rdi)
movupd %xmm0, (%rdi)
andq $0x0, 0x20(%rdi)
movq 0x48(%rsp), %r12
movq %r12, 0x8(%rdi)
movq %rsi, 0x10(%rdi)
xorl %ebp, %ebp
xorl %r13d, %r13d
cvtsi2sd %r13d, %xmm0
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0xe1be
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x199fb
incl %r13d
testb %al, %al
je 0xe196
movsbl %al, %ebp
movl %ebp, 0x20(%rbx)
movq %rbx, %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/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 %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movsd %xmm0, (%rsp)
movq %rsi, %r15
movq %rdi, %rbx
xorpd %xmm0, %xmm0
movupd %xmm0, 0x10(%rdi)
movupd %xmm0, (%rdi)
andq $0x0, 0x20(%rdi)
movq 0x48(%rsp), %r12
movq %r12, 0x8(%rdi)
movq %rsi, 0x10(%rdi)
xorl %ebp, %ebp
xorl %r13d, %r13d
cvtsi2sd %r13d, %xmm0
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0xe239
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x19d31
incl %r13d
testl %eax, %eax
je 0xe210
movl %eax, %ebp
movl %ebp, 0x20(%rbx)
movq %rbx, %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/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
movq %rdx, %r14
movsd %xmm0, 0x8(%rsp)
movq %rsi, %r15
xorpd %xmm0, %xmm0
andq $0x0, 0x20(%rdi)
movupd %xmm0, 0x10(%rdi)
movupd %xmm0, (%rdi)
movq 0x58(%rsp), %r12
movq %r12, 0x8(%rdi)
movq %rdi, 0x10(%rsp)
movq %rsi, 0x10(%rdi)
xorl %ebx, %ebx
pushq $0x1
popq %r13
xorl %ebp, %ebp
cvtsi2sd %ebp, %xmm0
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
jbe 0xe2e5
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
movl %r13d, %ecx
callq 0x19d31
addl %eax, %ebx
js 0xe2c6
incl %ebp
jmp 0xe29d
movq 0x1bd2b(%rip), %rax     # 0x29ff8
movq (%rax), %rdi
movl 0x8(%r12), %edx
leaq 0xf5bd(%rip), %rsi      # 0x1d899
movl %ebp, %ecx
xorl %eax, %eax
callq 0x1150
cvtsi2sd %ebx, %xmm0
divsd 0x8(%rsp), %xmm0
callq 0x1230
cvttsd2si %xmm0, %eax
cvttpd2dq %xmm0, %xmm0
cvtdq2pd %xmm0, %xmm0
movq 0x10(%rsp), %rcx
movl %eax, 0x20(%rcx)
movq %rcx, %rax
movsd 0x1be3d(%rip), %xmm1    # 0x2a150
ucomisd %xmm0, %xmm1
jbe 0xe31d
andl $0x0, 0x20(%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/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
movl $0x80, %ebp
xorl %r14d, %r14d
xorl %r12d, %r12d
xorl %eax, %eax
callq 0xac6e
testq %rax, %rax
je 0xe388
movq %rax, %r15
movslq %r12d, %rcx
movq (%rbx), %rax
cmpq %rcx, %r14
jl 0xe37f
leal (%r12,%r12), %r13d
testl %r12d, %r12d
cmovel %ebp, %r13d
movslq %r13d, %rsi
shlq $0x3, %rsi
movq %rax, %rdi
callq 0x11b0
movq %rax, (%rbx)
movl %r13d, %r12d
movq %r15, (%rax,%r14,8)
incq %r14
jmp 0xe345
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_O2/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, %r12
movq %rdx, %r14
movq %rdi, %r15
movslq %esi, %rax
movq %rax, 0x10(%rsp)
xorl %r13d, %r13d
movq $0x0, 0x8(%rsp)
movq %rcx, 0x20(%rsp)
movq %rdi, 0x18(%rsp)
xorl %eax, %eax
callq 0xac6e
testq %rax, %rax
je 0xe4c6
movq %rax, %rbp
cmpl $0x1, (%rax)
jg 0xe3f7
movq %rbp, %rdi
movq %r14, %rsi
callq 0x5dac
movq %rax, %rbx
jmp 0xe45b
movq %r12, (%rsp)
leaq 0x98bd(%rip), %rdi      # 0x17cbf
movq %rbp, %rsi
movq 0x10(%rsp), %rcx
movl %ecx, %edx
pushq $0x1
popq %r8
movq %r14, %r9
callq 0x181c4
movq %rax, %r15
xorl %ebx, %ebx
movq %rax, %r12
testq %r12, %r12
je 0xe446
cmpl $0x0, 0x10(%r12)
je 0xe43f
movq %r12, %rdi
movq %r14, %rsi
callq 0x5fe8
movq %rbx, 0x18(%rax)
movq %rax, %rbx
movq 0x18(%r12), %r12
jmp 0xe420
movq 0x20(%rsp), %r12
movq %r12, %rdi
movq %r15, %rsi
callq 0x11888
movq 0x18(%rsp), %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x5bb6
movq %rax, %rbx
movq 0x8(%rbp), %rax
movq %rax, 0x8(%rbx)
movq %rbx, %rdi
callq 0xe4d8
movq %r14, %rdi
movq %rbp, %rsi
callq 0x1166e
movq 0x8(%rsp), %rdx
movslq %edx, %rcx
movq (%r15), %rax
cmpq %rcx, %r13
jl 0xe4b5
leal (%rdx,%rdx), %ebp
testl %edx, %edx
movl $0x80, %ecx
cmovel %ecx, %ebp
movslq %ebp, %rsi
shlq $0x3, %rsi
movq %rax, %rdi
callq 0x11b0
movq %rax, (%r15)
movl %ebp, %edx
movq %rdx, 0x8(%rsp)
movq %rbx, (%rax,%r13,8)
incq %r13
jmp 0xe3cf
movl %r13d, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %r15
pushq %r14
pushq %rbx
movq %rdi, %rbx
xorl %r14d, %r14d
movslq (%rbx), %rax
cmpq %rax, %r14
jge 0xe537
movq 0x10(%rbx), %rax
movq (%rax,%r14,8), %r15
cmpl $0x0, 0x24(%r15)
jne 0xe529
movq (%r15), %rdi
callq 0x118b2
movq %rax, (%r15)
movl $0x1, 0x24(%r15)
jmp 0xe529
cmpl $0x0, 0x28(%r15)
jne 0xe529
movq (%r15), %rdi
callq 0x118b2
movq %rax, (%r15)
movl $0x1, 0x28(%r15)
movq 0x8(%r15), %r15
testq %r15, %r15
jne 0xe50f
incq %r14
jmp 0xe4e3
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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, %r15
movq %rsi, %r14
movq %rdi, %r12
leaq 0xc(%rsp), %rax
orl $-0x1, (%rax)
leaq 0x8(%rsp), %rax
orl $-0x1, (%rax)
movq %rdx, %rdi
callq 0x1180
movq %rax, 0x10(%rsp)
xorl %ebp, %ebp
xorl %r13d, %r13d
movq %r15, 0x18(%rsp)
movq %r14, 0x20(%rsp)
movq %r14, %rdi
leaq 0xf37a(%rip), %rsi      # 0x1d907
leaq 0x8(%rsp), %rdx
leaq 0xc(%rsp), %rcx
xorl %eax, %eax
callq 0x1060
cmpl $0x2, %eax
jne 0xe63d
movq %r14, %rdi
movq 0x10(%rsp), %rsi
movq %rbx, %rdx
callq 0x511a
movq %rax, %r14
movslq %r13d, %rax
cmpq %rax, %rbp
jl 0xe5f7
movq %rbx, %r15
leal (,%r13,2), %ebx
testl %r13d, %r13d
movl $0x80, %eax
cmovel %eax, %ebx
movq (%r12), %rdi
movslq %ebx, %rsi
shlq $0x3, %rsi
callq 0x11b0
movq %rax, (%r12)
movl %ebx, %r13d
movq %r15, %rbx
movq 0x18(%rsp), %r15
movq %r14, %rdi
movq %r15, %rsi
callq 0x58db
movq (%r12), %rcx
movq %rax, (%rcx,%rbp,8)
movl 0xc(%rsp), %eax
movq (%r12), %rcx
movq (%rcx,%rbp,8), %rdi
movl %eax, 0x8(%rdi)
movl 0x8(%rsp), %eax
movl %eax, 0xc(%rdi)
callq 0xe4d8
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1184e
incq %rbp
movq 0x20(%rsp), %r14
jmp 0xe583
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_O2/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 %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq %esi, %r15
leaq (,%r15,8), %rdi
callq 0x1180
movq %rax, %r14
xorl %r12d, %r12d
testl %r15d, %r15d
cmovlel %r12d, %r15d
cmpq %r12, %r15
je 0xeaea
movq (%rbx,%r12,8), %rdi
xorl %esi, %esi
callq 0x1945b
movq %rax, (%r14,%r12,8)
incq %r12
jmp 0xead1
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/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, 0x30(%rsp)
movq %rcx, %rbx
movq %rsi, 0x50(%rsp)
movq %rdi, %r12
movslq %edx, %r14
pushq $0x1
popq %r15
leaq 0x90(%rsp), %r13
xorl %ecx, %ecx
xorl %eax, %eax
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
je 0xef45
movq %rcx, 0x40(%rsp)
movq %rax, 0x38(%rsp)
pushq $0x1
popq %rdi
movq 0x30(%rsp), %rsi
callq 0x630e
movq %rax, %rbp
movq (%rbx), %rax
movq 0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rax, (%rcx)
movq %rbx, 0x48(%rsp)
movq 0x18(%rbx), %rax
movl %r15d, 0x20(%rax)
xorl %eax, %eax
callq 0x1a3dc
movq %rax, %rbx
movl %r15d, 0x2c(%rsp)
movl %r15d, 0x8(%rbp)
xorl %r15d, %r15d
cmpq %r15, %r14
je 0xef1a
xorps %xmm0, %xmm0
movups %xmm0, (%r13)
andq $0x0, 0x10(%r13)
movq (%r12,%r15,8), %rax
movq %rax, 0x88(%rsp)
movq 0x50(%rsp), %rax
movq (%rax,%r15,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 %rbp, %rsi
callq 0x834f
cmpl $0x0, 0x78(%rsp)
je 0xef01
movq 0x78(%rsp), %rax
movq %rax, 0x20(%rsp)
movups 0x58(%rsp), %xmm0
movups 0x68(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rbx, %rdi
callq 0x1a223
jmp 0xef12
movq 0x60(%rsp), %rax
movq 0x70(%rsp), %rdi
movl (%rax), %esi
callq 0x133ca
incq %r15
jmp 0xee6d
movq %rbx, %rax
movq 0x40(%rsp), %rcx
testq %rcx, %rcx
je 0xef30
movq %rbx, 0x10(%rcx)
movq 0x38(%rsp), %rax
movl 0x2c(%rsp), %r15d
incl %r15d
movq %rbx, %rcx
movq 0x48(%rsp), %rbx
jmp 0xee16
addq $0xa8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 %rdx, %rbx
movq %rdi, %r15
movslq %esi, %rax
movq %rax, 0x58(%rsp)
pushq $0x1
popq %r14
xorl %ecx, %ecx
xorl %eax, %eax
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
je 0xf80a
movq %rcx, 0x48(%rsp)
movq %rax, 0x40(%rsp)
pushq $0x1
popq %rdi
movq 0x38(%rsp), %rsi
callq 0x630e
movq %rax, %rbp
movq (%rbx), %rax
movq 0x10(%rbp), %rcx
movq (%rcx), %rcx
movq %rax, (%rcx)
movq %rbx, 0x50(%rsp)
movq 0x18(%rbx), %rax
movl %r14d, 0x20(%rax)
xorl %eax, %eax
callq 0x1a3dc
movq %rax, 0x30(%rsp)
movl %r14d, 0x2c(%rsp)
movl %r14d, 0x8(%rbp)
xorl %r14d, %r14d
cmpq 0x58(%rsp), %r14
je 0xf7da
leaq 0x78(%rsp), %rax
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
imulq $0x38, %r14, %rax
leaq (%r15,%rax), %rcx
movq (%r15,%rax), %r13
movq %r13, 0x68(%rsp)
movq %rbp, 0x70(%rsp)
movq %rcx, 0x60(%rsp)
movq 0x10(%rbp), %rax
movq (%rax), %rax
movq (%rax), %rbx
xorl %r12d, %r12d
movslq (%r13), %rax
cmpq %rax, %r12
jge 0xf7d2
movq 0x10(%r13), %rax
movq (%rax,%r12,8), %rax
movq (%rax), %rdi
movq %rbx, %rsi
callq 0x19340
incq %r12
testl %eax, %eax
jne 0xf77a
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 0x1a223
incq %r14
jmp 0xf73c
movq 0x30(%rsp), %rdx
movq %rdx, %rax
movq 0x48(%rsp), %rcx
testq %rcx, %rcx
je 0xf7f5
movq %rdx, 0x10(%rcx)
movq 0x40(%rsp), %rax
movl 0x2c(%rsp), %r14d
incl %r14d
movq %rdx, %rcx
movq 0x50(%rsp), %rbx
jmp 0xf6e3
addq $0x88, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x18dcd
movq 0x18(%rbx), %rsi
movq %r15, %rdi
callq 0x11888
movq 0x20(%rbx), %rsi
movq %r14, %rdi
callq 0x1166e
xorl %r15d, %r15d
movslq 0x28(%rbx), %rax
movq (%rbx), %rdi
cmpq %rax, %r15
jge 0xfa87
movq (%rdi,%r15,8), %rsi
movq %r14, %rdi
callq 0x1166e
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x1030
incq %r15
jmp 0xfa5d
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_O2/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 0x18dcd
movq 0x10(%rbx), %rsi
movq %r15, %rdi
callq 0x11888
movq 0x18(%rbx), %rsi
movq %r14, %rdi
callq 0x1166e
xorl %r15d, %r15d
xorl %r12d, %r12d
movslq 0x20(%rbx), %rax
movq (%rbx), %rdi
cmpq %rax, %r12
jge 0xfb35
movq (%rdi,%r15), %rsi
movq %r14, %rdi
callq 0x1166e
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 0xca2f
incq %r12
addq $0x38, %r15
jmp 0xfae0
callq 0x1030
movq %rbx, %rdi
addq $0x38, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1030