LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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), %rax
movslq 0x30(%rax), %r12
testq %r12, %r12
jle 0xf5c7
movq 0x18(%rax), %rcx
movq %rcx, 0x8(%rsp)
movq 0x20(%rax), %rbp
movq 0x28(%rax), %r15
xorl %ebx, %ebx
movq 0x8(%rsp), %rax
movq (%rax,%rbx,8), %rsi
movq 0x10(%rsp), %rdi
callq 0x148f4
testq %rbp, %rbp
je 0xf591
movq (%rbp,%rbx,8), %rax
testq %rax, %rax
je 0xf587
movq (%rax), %r14
testq %r14, %r14
je 0xf587
movq 0x28(%r14), %r13
movq 0x8(%r14), %rax
movq 0x18(%r14), %rdi
movl (%rax), %esi
callq 0x1631f
movq %r14, %rdi
callq 0x1030
movq %r13, %r14
testq %r13, %r13
jne 0xf564
movq (%rbp,%rbx,8), %rdi
callq 0x1030
testq %r15, %r15
je 0xf5bb
movq (%r15,%rbx,8), %r14
testq %r14, %r14
je 0xf5bb
movq (%r14), %rdi
movq 0x8(%r14), %r13
callq 0x1030
movq %r14, %rdi
callq 0x1030
movq %r13, %r14
testq %r13, %r13
jne 0xf59f
incq %rbx
cmpq %r12, %rbx
jne 0xf53a
leaq 0x50(%rsp), %rbx
movq 0x10(%rbx), %rdi
callq 0x1030
movq 0x8(%rbx), %rdi
callq 0x1030
movq 0x18(%rbx), %rdi
callq 0x1030
movq 0x28(%rbx), %rdi
callq 0x1030
movq 0x20(%rbx), %rdi
addq $0x18, %rsp
testq %rdi, %rdi
je 0xf60c
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1030
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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), %rbx
leaq 0x11266(%rip), %rdi     # 0x20894
callq 0x1070
movq (%rbx), %rdi
callq 0x8c19
movslq 0x30(%rbx), %rbx
leaq 0x111fa(%rip), %rdi     # 0x20840
xorl %ebp, %ebp
movl %ebx, %esi
xorl %eax, %eax
callq 0x10b0
testq %rbx, %rbx
jle 0xf677
leaq 0x40(%rsp), %rax
movq 0x18(%rax), %rax
xorl %ecx, %ecx
xorl %ebp, %ebp
movq (%rax,%rcx,8), %rdx
cmpq $0x1, 0x18(%rdx)
sbbl $-0x1, %ebp
incq %rcx
cmpq %rcx, %rbx
jne 0xf663
leaq 0x111cf(%rip), %rdi     # 0x2084d
movl %ebp, %esi
xorl %eax, %eax
callq 0x10b0
leaq 0x11213(%rip), %rdi     # 0x208a1
callq 0x1070
testl %ebx, %ebx
jle 0xf6e4
leaq 0x40(%rsp), %rax
movq 0x8(%rax), %r12
movq 0x10(%rax), %r13
movq 0x18(%rax), %rbp
leaq 0x111b4(%rip), %r14     # 0x20863
xorl %r15d, %r15d
movq (%r12,%r15,8), %rax
movq (%r13,%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 0x8c19
incq %r15
cmpq %r15, %rbx
jne 0xf6b2
leaq 0x111cc(%rip), %rdi     # 0x208b7
callq 0x1070
testl %ebx, %ebx
jle 0xf785
leaq 0x40(%rsp), %rax
movq 0x8(%rax), %rcx
movq %rcx, (%rsp)
movq 0x10(%rax), %r13
movq 0x20(%rax), %rbp
movq 0x1d8b4(%rip), %r15     # 0x2cfc8
xorl %r14d, %r14d
movq (%rsp), %rax
movq (%rax,%r14,8), %rax
movl 0x18(%rax), %esi
movq (%r13,%r14,8), %rax
movl 0x18(%rax), %edx
leaq 0x11151(%rip), %rdi     # 0x20882
xorl %eax, %eax
callq 0x10b0
testq %rbp, %rbp
je 0xf771
movq (%rbp,%r14,8), %rax
testq %rax, %rax
je 0xf771
movq (%rax), %r12
testq %r12, %r12
je 0xf77d
movq 0x18(%r12), %rdi
movq 0x8(%r12), %rax
movq 0x10(%r12), %rcx
movl (%rax), %esi
movl (%rcx), %edx
movq (%r15), %rcx
callq 0x163ad
movq 0x28(%r12), %r12
jmp 0xf74a
leaq 0x11150(%rip), %rdi     # 0x208c8
callq 0x1070
incq %r14
cmpq %rbx, %r14
jne 0xf717
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xe85c
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 0xf05d
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0xfadf
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 0xf502
movl %ebp, %eax
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xe85c
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 0xf2cf
movq %r12, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0xfadf
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 0xf502
movl %ebp, %eax
addq $0xa0, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xffbb
movslq %r12d, %rax
movq (%r14,%rax,8), %r15
testq %r15, %r15
je 0x10054
xorl %r12d, %r12d
movq %r15, %rdi
movq %rbx, %rsi
callq 0x87fa
movq %rax, %r14
movq %r12, 0x18(%rax)
movq 0x18(%r15), %r15
movq %rax, %r12
testq %r15, %r15
jne 0xff98
jmp 0x10057
leal 0x1(%r12), %esi
movq %r14, %rdi
movq %rbx, %rcx
callq 0xff6a
movq %rax, %r15
movslq %r12d, %rax
movq (%r14,%rax,8), %r12
xorl %r14d, %r14d
testq %r12, %r12
je 0x10047
movq %r15, %r13
testq %r15, %r15
je 0x10040
movq %r12, %rdi
movq %rbx, %rsi
callq 0x87fa
movq %rax, %rbp
movq %r13, %rdi
movq %rbx, %rsi
callq 0x87fa
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 0x14b19
movq %r14, 0x18(%rbp)
movq 0x18(%r13), %r13
movq %rbp, %r14
testq %r13, %r13
jne 0xffe5
movq 0x18(%r12), %r12
jmp 0xffd8
movq %rbx, %rdi
movq %r15, %rsi
callq 0x14b75
jmp 0x10057
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_O1/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 0x9a7d(%rip), %rdi      # 0x1a3e2
movl %ecx, %edx
movl $0x1, %r8d
callq 0x1a9ac
xorl %r14d, %r14d
testq %rax, %rax
je 0x109a6
xorl %r15d, %r15d
xorl %esi, %esi
movq 0x18(%rax), %rcx
cmpl $0x0, 0x10(%rax)
je 0x10992
movq %r15, 0x18(%rax)
movq %rax, %r15
jmp 0x1099c
movq %rsi, 0x18(%rax)
incl %r14d
movq %rax, %rsi
movq %rcx, %rax
testq %rcx, %rcx
jne 0x1097f
jmp 0x109ab
xorl %esi, %esi
xorl %r15d, %r15d
movq %rbx, %rdi
callq 0x14b75
movl %r14d, %eax
cltd
idivl %ebp
movl %eax, %ebp
movq %r15, %rdi
movq %rbx, %rsi
callq 0xee8a
testq %rax, %rax
je 0x109d9
movq %rax, %rcx
incl %ebp
movq 0x18(%rcx), %rcx
testq %rcx, %rcx
jne 0x109ce
movq %rbx, %rdi
movq %rax, %rsi
callq 0x14b75
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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 0x10a62
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 0x10a58
xorl %r14d, %r14d
movq (%r12,%r13,8), %rdi
movq (%r15,%r14,8), %rsi
movq %rbx, %rdx
callq 0xabfd
testb %al, %al
je 0x10a50
movq 0x10(%rsp), %rax
movq (%rax,%r14,8), %rax
incl 0x1c(%rax)
incq %r14
cmpq %r14, %rbp
jne 0x10a30
incq %r13
cmpq 0x8(%rsp), %r13
jne 0x10a26
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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)
movq $0x0, 0x18(%rdi)
movq 0x8(%rdi), %rdi
cvttsd2si %xmm0, %edx
callq 0xfe03
movsbl %al, %eax
movl %eax, 0x20(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/lwm_embeddingOperators.c
// Function: localEasyOperator
struct SubtreeIsoDataStore localEasyOperator(struct SubtreeIsoDataStore data, struct Graph* h, double importance, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	(void)importance; // unused
	(void)sgp; // unused

	struct SubtreeIsoDataStore result = data;
	result.h = h;
	result.S = NULL;
	struct SpanningtreeTree* sptTree = (struct SpanningtreeTree*)data.postorder;

	result.foundIso = subtreeCheckForSpanningtreeTree(sptTree, h, gp);

	// clean up the spanning tree tree
	wipeCharacteristicsForLocalEasy(*sptTree);

	return result;
}

// Assembly:
pushq %r14
pushq %rbx
subq $0x38, %rsp
movq %rdi, %rbx
movaps 0x50(%rsp), %xmm0
movaps 0x60(%rsp), %xmm1
movups %xmm1, 0x10(%rdi)
movq 0x70(%rsp), %rax
movq %rax, 0x20(%rdi)
movups %xmm0, (%rdi)
movq %rsi, 0x10(%rdi)
movq $0x0, 0x18(%rdi)
movq 0x50(%rsp), %r14
movq %r14, %rdi
callq 0xfadf
movsbl %al, %eax
movl %eax, 0x20(%rbx)
movq 0x30(%r14), %rax
movq %rax, 0x30(%rsp)
movups (%r14), %xmm0
movups 0x10(%r14), %xmm1
movups 0x20(%r14), %xmm2
movups %xmm2, 0x20(%rsp)
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0xf483
movq %rbx, %rax
addq $0x38, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x98cc
movsbl %al, %eax
movl %eax, 0x20(%rbx)
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/lwm_embeddingOperators.c
// Function: alwaysReturnTrue
struct SubtreeIsoDataStore alwaysReturnTrue(struct SubtreeIsoDataStore data, struct Graph* h, double importance, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	(void)importance; // unused
	(void)sgp; // unused
	(void)gp; // unused
	struct SubtreeIsoDataStore result = data;
	result.h = h;
	result.S = NULL;
	result.foundIso = 1;
	return result;
}

// Assembly:
movq %rdi, %rax
movaps 0x8(%rsp), %xmm0
movaps 0x18(%rsp), %xmm1
movups %xmm1, 0x10(%rdi)
movq 0x28(%rsp), %rcx
movq %rcx, 0x20(%rdi)
movups %xmm0, (%rdi)
movq %rsi, 0x10(%rdi)
movq $0x0, 0x18(%rdi)
movl $0x1, 0x20(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x10cb7
movq %rsi, %r14
movl $0x1, %ebp
movq %r15, %rdi
movq %r14, %rsi
callq 0x1bf30
testb %al, %al
jne 0x10cb1
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
incl %ebp
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm1
ja 0x10c8e
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_O1/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 0x10d31
movq %rsi, %r14
movl $0x1, %ebp
movq %r15, %rdi
movq %r14, %rsi
callq 0x1c15f
testb %al, %al
jne 0x10d2b
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
incl %ebp
movsd (%rsp), %xmm1
ucomisd %xmm0, %xmm1
ja 0x10d08
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_O1/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 0x10db8
movq %rdx, %r14
movq %rsi, %r15
movl $0x1, %ebp
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x1c3d7
testb %al, %al
jne 0x10db2
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
incl %ebp
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
ja 0x10d8b
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_O1/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 0x10e40
movq %rdx, %r14
movq %rsi, %r15
movl $0x1, %ebp
movq %r12, %rdi
movq %r15, %rsi
movq %r14, %rdx
xorl %ecx, %ecx
callq 0x1c726
testl %eax, %eax
jne 0x10e3d
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
incl %ebp
movsd 0x8(%rsp), %xmm1
ucomisd %xmm0, %xmm1
ja 0x10e14
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_O1/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, 0x8(%rsp)
movq %rsi, 0x10(%rdi)
xorl %ebp, %ebp
xorpd %xmm1, %xmm1
movsd %xmm0, 0x10(%rsp)
ucomisd %xmm1, %xmm0
jbe 0x10edd
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 0x1c726
movl %eax, %ebp
addl %ebx, %ebp
js 0x10f2a
incl %r13d
xorps %xmm0, %xmm0
cvtsi2sd %r13d, %xmm0
movsd 0x10(%rsp), %xmm1
ucomisd %xmm0, %xmm1
ja 0x10eab
xorps %xmm0, %xmm0
cvtsi2sd %ebp, %xmm0
divsd 0x10(%rsp), %xmm0
callq 0x1240
cvttsd2si %xmm0, %eax
cvttpd2dq %xmm0, %xmm0
cvtdq2pd %xmm0, %xmm0
movq 0x8(%rsp), %rcx
movl %eax, 0x20(%rcx)
movq %rcx, %rax
movsd 0x1c24a(%rip), %xmm1    # 0x2d158
ucomisd %xmm0, %xmm1
jbe 0x10f1b
movl $0x0, 0x20(%rax)
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x8(%rsp), %rax
movl $0x7fffffff, 0x20(%rax) # imm = 0x7FFFFFFF
movq 0x1c0bb(%rip), %rax     # 0x2cff8
movq (%rax), %rdi
movl 0x8(%r12), %edx
leaq 0xf982(%rip), %rsi      # 0x208ce
movl %r13d, %ecx
xorl %eax, %eax
callq 0x1160
jmp 0x10edd
// File: /workspace/github_c_makefile_star2_O1/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 0xd362
testq %rax, %rax
je 0x10fc4
movq %rax, %r15
movl $0x80, %ebp
xorl %r14d, %r14d
xorl %r12d, %r12d
movslq %r12d, %rax
cmpq %rax, %r14
jl 0x10fab
leal (%r12,%r12), %r13d
testl %r12d, %r12d
cmovel %ebp, %r13d
movq (%rbx), %rdi
movslq %r13d, %rsi
shlq $0x3, %rsi
callq 0x11c0
movq %rax, (%rbx)
movl %r13d, %r12d
movq (%rbx), %rax
movq %r15, (%rax,%r14,8)
incq %r14
xorl %eax, %eax
callq 0xd362
movq %rax, %r15
testq %rax, %rax
jne 0x10f83
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_O1/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 0xd362
testq %rax, %rax
je 0x1111d
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 0x11039
movq %rbp, %rdi
movq %r14, %rsi
callq 0x7f7e
movq %rax, %rbx
jmp 0x110a4
movq %r13, (%rsp)
leaq 0x939e(%rip), %rdi      # 0x1a3e2
movq %rbp, %rsi
movq 0x10(%rsp), %rcx
movl %ecx, %edx
movl $0x1, %r8d
movq %r14, %r9
callq 0x1a9ac
movq %rax, %r15
testq %rax, %rax
je 0x1108d
movq %r15, %r13
xorl %ebx, %ebx
cmpl $0x0, 0x10(%r13)
je 0x11082
movq %r13, %rdi
movq %r14, %rsi
callq 0x81e0
movq %rbx, 0x18(%rax)
movq %rax, %rbx
movq 0x18(%r13), %r13
testq %r13, %r13
jne 0x11069
jmp 0x1108f
xorl %ebx, %ebx
movq 0x20(%rsp), %r13
movq %r13, %rdi
movq %r15, %rsi
callq 0x14b75
movq 0x18(%rsp), %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x7d63
movq %rax, %rbx
movq 0x8(%rbp), %rax
movq %rax, 0x8(%rbx)
movq %rbx, %rdi
callq 0x1112f
movq %r14, %rdi
movq %rbp, %rsi
callq 0x14832
movq 0x8(%rsp), %rcx
movslq %ecx, %rax
cmpq %rax, %r12
jl 0x11100
leal (%rcx,%rcx), %ebp
testl %ecx, %ecx
movl $0x80, %eax
cmovel %eax, %ebp
movq (%r15), %rdi
movslq %ebp, %rsi
shlq $0x3, %rsi
callq 0x11c0
movq %rax, (%r15)
movl %ebp, %eax
movq %rax, 0x8(%rsp)
movq (%r15), %rax
movq %rbx, (%rax,%r12,8)
incq %r12
xorl %eax, %eax
callq 0xd362
movq %rax, %rbp
testq %rax, %rax
jne 0x11023
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_O1/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 0x11196
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 0x1117d
movq (%r15), %rdi
callq 0x14ba7
movq %rax, (%r15)
movl $0x1, 0x24(%r15)
jmp 0x1117d
cmpl $0x0, 0x28(%r15)
jne 0x1117d
movq (%r15), %rdi
callq 0x14ba7
movq %rax, (%r15)
movl $0x1, 0x28(%r15)
movq 0x8(%r15), %r15
testq %r15, %r15
jne 0x11163
incq %r14
movslq (%rbx), %rax
cmpq %rax, %r14
jl 0x1113f
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xf762(%rip), %rsi      # 0x2093c
xorl %ebp, %ebp
movq %r12, %rdi
movq %r14, %rdx
movq %r15, %rcx
xorl %eax, %eax
callq 0x1060
cmpl $0x2, %eax
jne 0x112bb
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 0x71ec
movq %rax, %r14
movslq %r13d, %rax
cmpq %rax, %rbp
jge 0x11226
movq 0x8(%rsp), %r15
jmp 0x1125e
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 0x7a56
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 0x1112f
movq %rbx, %rdi
movq %r14, %rsi
callq 0x14b19
incq %rbp
movq %r12, %rdi
leaq 0xf699(%rip), %rsi      # 0x2093c
movq %rsp, %rdx
leaq 0x4(%rsp), %rcx
xorl %eax, %eax
callq 0x1060
cmpl $0x2, %eax
je 0x11204
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_O1/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 0x117b9
movl %ebp, %r15d
xorl %r12d, %r12d
movq (%rbx,%r12,8), %rdi
xorl %esi, %esi
callq 0x1bd4a
movq %rax, (%r14,%r12,8)
incq %r12
cmpq %r12, %r15
jne 0x117a2
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x8(%rcx), %r13
testq %r13, %r13
je 0x11c35
movq %rsi, %r14
movq %rdi, %r15
movslq %edx, %rbp
movl $0x1, %r12d
movq $0x0, 0x30(%rsp)
xorl %esi, %esi
movl %edx, 0x28(%rsp)
movq %rsi, 0x40(%rsp)
movl $0x1, %edi
movq 0x38(%rsp), %rsi
callq 0x8565
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 %r12d, 0x20(%rax)
xorl %eax, %eax
callq 0x1cf87
movq %rax, %r13
movl %r12d, 0x2c(%rsp)
movl %r12d, 0x8(%rbx)
cmpl $0x0, 0x28(%rsp)
je 0x11bf8
xorl %r12d, %r12d
xorps %xmm0, %xmm0
movaps %xmm0, 0x60(%rsp)
movaps %xmm0, 0x50(%rsp)
movq $0x0, 0x70(%rsp)
movq (%r15,%r12,8), %rax
movq %rax, 0x58(%rsp)
movq (%r14,%r12,8), %rax
movq %rax, 0x50(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x20(%rsp)
movaps 0x50(%rsp), %xmm0
movaps 0x60(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
leaq 0x80(%rsp), %rdi
movq %rbx, %rsi
callq 0xa819
cmpl $0x0, 0xa0(%rsp)
je 0x11bd5
movq 0xa0(%rsp), %rax
movq %rax, 0x20(%rsp)
movups 0x80(%rsp), %xmm0
movups 0x90(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %r13, %rdi
callq 0x1cd7a
jmp 0x11bec
movq 0x88(%rsp), %rax
movq 0x98(%rsp), %rdi
movl (%rax), %esi
callq 0x1631f
incq %r12
cmpq %r12, %rbp
jne 0x11b46
movq %r13, %rax
movq 0x40(%rsp), %rcx
testq %rcx, %rcx
je 0x11c0e
movq %r13, 0x10(%rcx)
movq 0x30(%rsp), %rax
movl 0x2c(%rsp), %r12d
incl %r12d
movq 0x48(%rsp), %rcx
movq 0x8(%rcx), %rcx
movq %rax, 0x30(%rsp)
movq %r13, %rsi
movq %rcx, %r13
testq %rcx, %rcx
jne 0x11af3
jmp 0x11c37
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_O1/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 0x1b644
movq 0x18(%rbx), %rsi
movq %r15, %rdi
callq 0x14b75
movq 0x20(%rbx), %rsi
movq %r14, %rdi
callq 0x14832
cmpl $0x0, 0x28(%rbx)
jle 0x12862
xorl %r15d, %r15d
movq (%rbx), %rax
movq (%rax,%r15,8), %rsi
movq %r14, %rdi
callq 0x14832
movq 0x8(%rbx), %rax
movq (%rax,%r15,8), %rdi
callq 0x1030
incq %r15
movslq 0x28(%rbx), %rax
cmpq %rax, %r15
jl 0x1283a
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_O1/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 0x1b644
movq 0x10(%rbx), %rsi
movq %r15, %rdi
callq 0x14b75
movq 0x18(%rbx), %rsi
movq %r14, %rdi
callq 0x14832
cmpl $0x0, 0x20(%rbx)
jle 0x12917
xorl %r15d, %r15d
xorl %r12d, %r12d
movq (%rbx), %rax
movq (%rax,%r15), %rsi
movq %r14, %rdi
callq 0x14832
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 0xf502
incq %r12
movslq 0x20(%rbx), %rax
addq $0x38, %r15
cmpq %rax, %r12
jl 0x128c4
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_O1/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 $0x88, %rsp
movq %rcx, 0x70(%rsp)
movq 0x8(%rdx), %r15
testq %r15, %r15
je 0x12a62
movq %rdi, %r14
movslq %esi, %rbx
movl $0x1, %r13d
xorl %ebp, %ebp
movq $0x0, 0x38(%rsp)
xorl %edx, %edx
movl %esi, 0x30(%rsp)
movq %rdx, 0x78(%rsp)
movl $0x1, %edi
movq 0x70(%rsp), %rsi
callq 0x8565
movq %rax, %r12
movq (%r15), %rax
movq 0x10(%r12), %rcx
movq (%rcx), %rcx
movq %rax, (%rcx)
movq %r15, 0x80(%rsp)
movq 0x18(%r15), %rax
movl %r13d, 0x20(%rax)
xorl %eax, %eax
callq 0x1cf87
movq %rax, %r15
movl %r13d, 0x34(%rsp)
movl %r13d, 0x8(%r12)
cmpl $0x0, 0x30(%rsp)
xorps %xmm0, %xmm0
je 0x12a22
xorl %r13d, %r13d
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
movq %rbp, 0x60(%rsp)
movq (%r14,%r13,8), %rax
movq %rax, 0x48(%rsp)
movq %r12, 0x50(%rsp)
movq %rbp, 0x40(%rsp)
movl $0x1, 0x60(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x20(%rsp)
movaps 0x40(%rsp), %xmm0
movaps 0x50(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %r15, %rdi
callq 0x1cd7a
xorps %xmm0, %xmm0
incq %r13
cmpq %r13, %rbx
jne 0x129c8
movq %r15, %rax
movq 0x78(%rsp), %rcx
testq %rcx, %rcx
je 0x12a38
movq %r15, 0x10(%rcx)
movq 0x38(%rsp), %rax
movl 0x34(%rsp), %r13d
incl %r13d
movq 0x80(%rsp), %rcx
movq 0x8(%rcx), %rcx
movq %rax, 0x38(%rsp)
movq %r15, %rdx
movq %rcx, %r15
testq %rcx, %rcx
jne 0x12972
jmp 0x12a64
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_O1/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 0x1b644
movq 0x18(%rbx), %rsi
movq %r15, %rdi
callq 0x14b75
movq 0x20(%rbx), %rsi
movq %r14, %rdi
callq 0x14832
cmpl $0x0, 0x28(%rbx)
jle 0x12c01
xorl %r15d, %r15d
movq (%rbx), %rax
movq (%rax,%r15,8), %rsi
movq %r14, %rdi
callq 0x14832
incq %r15
movslq 0x28(%rbx), %rax
cmpq %rax, %r15
jl 0x12be6
movq (%rbx), %rdi
callq 0x1030
movq %rbx, %rdi
popq %rbx
popq %r14
popq %r15
jmp 0x1030
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x1d206
movq %rax, %rdi
movl %ebx, %esi
callq 0x1d2c6
movq %rax, %r14
movq %rax, %rdi
callq 0x1d167
movq %rax, %rbx
testq %r14, %r14
je 0x12c5e
movq 0x10(%r14), %r15
movq %r14, %rdi
callq 0x1030
movq %r15, %r14
testq %r15, %r15
jne 0x12c4a
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/memoryManagement.c
// Function: createListPool
struct ListPool* createListPool(unsigned int initNumberOfElements){
	struct ListPool* newPool;

	if (MEM_DEBUG) {
		// this allows the dump methods to free everything that is dumped
		initNumberOfElements = 1;
	}

	if ((newPool = malloc(sizeof(struct ListPool)))) {
		if ((newPool->unused = malloc(initNumberOfElements * sizeof(struct VertexList)))) {
			unsigned int i;
			/* we have allocated an array, but need a list, thus set ponters accordingly */
			for (i=0; i<initNumberOfElements-1; ++i) {
				(newPool->unused[i]).next = &(newPool->unused[i+1]);
			}
			(newPool->unused[initNumberOfElements-1]).next = NULL;
			newPool->poolPointer = newPool->unused;
			newPool->initNumberOfElements = initNumberOfElements;
		} else {
			printf("Error while initializing object pool for list elements\n");
			return NULL;
		}
	} else {
		printf("Error while initializing object pool for list elements\n");
		return NULL;
	}
	return newPool;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %edi, %ebp
movl $0x20, %edi
callq 0x1190
testq %rax, %rax
je 0x142c1
movq %rax, %rbx
movl %ebp, %eax
shlq $0x4, %rax
leaq (%rax,%rax,2), %rdi
callq 0x1190
movq %rax, (%rbx)
testq %rax, %rax
je 0x142c1
movl %ebp, %ecx
decl %ecx
movl %ecx, %ecx
je 0x142a7
leaq 0x1(%rcx), %rdx
andq $-0x2, %rdx
leaq -0x1(%rcx), %rsi
movq %rsi, %xmm0
pshufd $0x44, %xmm0, %xmm0     # xmm0 = xmm0[0,1,0,1]
leaq 0x38(%rax), %rsi
movdqa 0xc608(%rip), %xmm1     # 0x20810
movdqa 0xc610(%rip), %xmm2     # 0x20820
pxor %xmm2, %xmm0
pcmpeqd %xmm3, %xmm3
movdqa 0xc610(%rip), %xmm4     # 0x20830
movdqa %xmm1, %xmm5
pxor %xmm2, %xmm5
movdqa %xmm5, %xmm6
pcmpgtd %xmm0, %xmm6
pcmpeqd %xmm0, %xmm5
pshufd $0xf5, %xmm5, %xmm5     # xmm5 = xmm5[1,1,3,3]
pand %xmm6, %xmm5
pshufd $0xf5, %xmm6, %xmm6     # xmm6 = xmm6[1,1,3,3]
por %xmm5, %xmm6
movdqa %xmm1, %xmm5
psubq %xmm3, %xmm5
movd %xmm6, %edi
notl %edi
testb $0x1, %dil
je 0x1426e
movq %xmm5, %rdi
leaq (%rdi,%rdi,2), %rdi
shlq $0x4, %rdi
addq %rax, %rdi
movq %rdi, -0x30(%rsi)
pxor %xmm3, %xmm6
pextrw $0x4, %xmm6, %edi
testb $0x1, %dil
je 0x14295
pshufd $0xee, %xmm5, %xmm5     # xmm5 = xmm5[2,3,2,3]
movq %xmm5, %rdi
leaq (%rdi,%rdi,2), %rdi
shlq $0x4, %rdi
addq %rax, %rdi
movq %rdi, (%rsi)
paddq %xmm4, %xmm1
addq $0x60, %rsi
addq $-0x2, %rdx
jne 0x14220
leaq (%rcx,%rcx,2), %rcx
shlq $0x4, %rcx
movq $0x0, 0x8(%rax,%rcx)
movq %rax, 0x18(%rbx)
movl %ebp, 0x10(%rbx)
jmp 0x142cf
leaq 0xc828(%rip), %rdi      # 0x20af0
callq 0x1070
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/memoryManagement.c
// Function: freeListPool
void freeListPool(struct ListPool *p) {
	while (p->unused) {
		p->tmp = p->unused->next;
		if ((p->unused < p->poolPointer) || (p->unused > &(p->poolPointer[p->initNumberOfElements-1]))) {
			free(p->unused);
		}
		p->unused = p->tmp;
	}
	if (!MEM_DEBUG) {
		free(p->poolPointer);
	}
	free(p);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x14319
movq 0x8(%rdi), %rax
movq %rax, 0x8(%rbx)
movq 0x18(%rbx), %rax
cmpq %rax, %rdi
jb 0x1430b
movl 0x10(%rbx), %ecx
decl %ecx
leaq (%rcx,%rcx,2), %rcx
shlq $0x4, %rcx
addq %rcx, %rax
cmpq %rax, %rdi
jbe 0x14310
callq 0x1030
movq 0x8(%rbx), %rdi
movq %rdi, (%rbx)
jmp 0x142e0
movq 0x18(%rbx), %rdi
callq 0x1030
movq %rbx, %rdi
popq %rbx
jmp 0x1030