LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/supportSet.c
// Function: popSupportSetElement
struct SupportSetElement* popSupportSetElement(struct SupportSet* s) {
	struct SupportSetElement* e = s->first;
	if (s->first != NULL) {
		s->first = e->next;
		s->size -= e->data.foundIso;
	}
	return e;
}

// Assembly:
movq (%rdi), %rax
testq %rax, %rax
je 0x1a2c2
movq 0x28(%rax), %rcx
movq %rcx, (%rdi)
movslq 0x20(%rax), %rcx
subq %rcx, 0x18(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/supportSet.c
// Function: popSupportSetData
struct SubtreeIsoDataStore popSupportSetData(struct SupportSet *s) {
	struct SupportSetElement* e = popSupportSetElement(s);
	struct SubtreeIsoDataStore data = e->data;
	free(e);
	return data;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x1a2ab
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups %xmm0, (%rbx)
movups %xmm1, 0x10(%rbx)
movq 0x20(%rax), %rcx
movq %rcx, 0x20(%rbx)
movq %rax, %rdi
callq 0x1030
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/supportSet.c
// Function: printSupportSet
void printSupportSet(struct SupportSet* l, FILE* out) {
	fprintf(out, "%zu elements: [", l->size);
	for (struct SupportSetElement* i=l->first; i!=NULL; i=i->next) {
		fprintf(out, "%i, ", i->data.g->number);
	}
	fprintf(out, "]\n");

}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %rdx
leaq 0x30d3(%rip), %rsi      # 0x1d3db
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1150
leaq 0x30d2(%rip), %r15      # 0x1d3eb
movq (%r14), %r14
testq %r14, %r14
je 0x1a33b
movq 0x8(%r14), %rax
movl 0x8(%rax), %edx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x1150
addq $0x28, %r14
jmp 0x1a319
leaq 0x2d2e(%rip), %rdi      # 0x1d070
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x1210
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/supportSet.c
// Function: printSupportSetSparse
void printSupportSetSparse(struct SupportSet* l, FILE* out) {
	fprintf(out, "%i:", l->first->data.h->number);
	for (struct SupportSetElement* e=l->first; e!=NULL; e=e->next) {
		fprintf(out, " %i", e->data.g->number);
	}
	fprintf(out, "\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movq 0x10(%rax), %rax
movl 0x8(%rax), %edx
leaq 0x3085(%rip), %rsi      # 0x1d3f6
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1150
leaq 0x41c7(%rip), %r15      # 0x1e549
movq (%r14), %r14
testq %r14, %r14
je 0x1a3a4
movq 0x8(%r14), %rax
movl 0x8(%rax), %edx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x1150
addq $0x28, %r14
jmp 0x1a382
pushq $0xa
popq %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x1100
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/supportSet.c
// Function: dumpSupportSetElements
void dumpSupportSetElements(struct SupportSetElement* e) {
	if (e->next != NULL) {
		dumpSupportSetElements(e->next);
	}

	dumpNewCube(e->data.S, e->data.g->n);
	free(e);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
testq %rdi, %rdi
je 0x1a430
callq 0x1a41e
movq 0x8(%rbx), %rax
movq 0x18(%rbx), %rdi
movl (%rax), %esi
callq 0x133ca
movq %rbx, %rdi
popq %rbx
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/supportSet.c
// Function: dumpSupportSetElementsWithPostorder
void dumpSupportSetElementsWithPostorder(struct SupportSetElement* e, struct GraphPool* gp) {
	if (e->next != NULL) {
		dumpSupportSetElementsWithPostorder(e->next, gp);
	}

	dumpNewCube(e->data.S, e->data.g->n);
	dumpGraph(gp, e->data.h);
	free(e->data.postorder);
	free(e);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
testq %rdi, %rdi
je 0x1a47f
movq %r14, %rsi
callq 0x1a464
movq 0x8(%rbx), %rax
movq 0x18(%rbx), %rdi
movl (%rax), %esi
callq 0x133ca
movq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x1166e
movq (%rbx), %rdi
callq 0x1030
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/supportSet.c
// Function: intersectTwoSupportSets
struct SupportSet* intersectTwoSupportSets(struct SupportSet* l1, struct SupportSet* l2) {
	struct SupportSet* supportList = getSupportSet();

	struct SupportSetElement* a = l1->first;
	struct SupportSetElement* b = l2->first;

	/* Once one or the other list runs out -- we're done */
	while (a != NULL && b != NULL)
	{
		if (a->data.g->number == b->data.g->number)
		{
			appendSupportSetData(supportList, a->data);
			a = a->next;
			b = b->next;
		}
		else if (a->data.g->number < b->data.g->number) /* advance the smaller list */
			a = a->next;
		else
			b = b->next;
	}
	return supportList;

}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
callq 0x1a3dc
movq %rax, %r14
movq (%r15), %r13
pushq $0x1
popq %r15
pushq $0x30
popq %r12
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x1a56f
testq %r13, %r13
je 0x1a56f
movq 0x8(%rbx), %rax
movq 0x8(%r13), %rcx
movl 0x8(%rcx), %ecx
cmpl %ecx, 0x8(%rax)
je 0x1a539
jl 0x1a569
movq 0x28(%r13), %r13
jmp 0x1a517
movq %r15, %rdi
movq %r12, %rsi
callq 0x1110
movq 0x20(%rbx), %rcx
movups (%rbx), %xmm0
movups 0x10(%rbx), %xmm1
movups %xmm0, (%rax)
movups %xmm1, 0x10(%rax)
movq %rcx, 0x20(%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0x1a204
movq 0x28(%r13), %r13
addq $0x28, %rbx
jmp 0x1a514
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/supportSet.c
// Function: intersectSupportSets
struct SupportSet* intersectSupportSets(struct SupportSet* aprioriList) {
	if (aprioriList == NULL) {
		return NULL;
	}
	if (aprioriList->next == NULL) {
		return intersectTwoSupportSets(aprioriList, aprioriList); // copy
	}

	struct SupportSet* intersection = intersectTwoSupportSets(aprioriList, aprioriList->next);
	for (struct SupportSet* support=aprioriList->next->next; support!=NULL; support=support->next) {
		struct SupportSet* tmp = intersectTwoSupportSets(intersection, support);
		dumpSupportSetCopy(intersection);
		intersection = tmp;
	}

	return intersection;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1a5c2
movq %rdi, %r14
movq 0x10(%rdi), %rsi
testq %rsi, %rsi
je 0x1a5cd
callq 0x1a4f2
movq %rax, %rbx
movq 0x10(%r14), %r14
movq 0x10(%r14), %r14
testq %r14, %r14
je 0x1a5c4
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1a4f2
movq %rax, %r15
movq %rbx, %rdi
callq 0x1a402
movq %r15, %rbx
jmp 0x1a59e
xorl %ebx, %ebx
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
movq %r14, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x1a4f2
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/supportSet.c
// Function: isSortedSupportSetOnPatterns
char isSortedSupportSetOnPatterns(struct SupportSet* l) {
	if (l->size < 2) {
		return 1;
	}
	for (struct SupportSet* e=l; e->next!=NULL; e=e->next) {
		if (e->first->data.h->number >= e->next->first->data.h->number) {
			return 0;
		}
	}
	return 1;
}

// Assembly:
movb $0x1, %al
cmpq $0x2, 0x18(%rdi)
jb 0x1a60b
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x1a605
movq (%rdi), %rcx
movq 0x10(%rcx), %rcx
movl 0x8(%rcx), %ecx
movq (%rax), %rdx
movq 0x10(%rdx), %rdx
movq %rax, %rdi
cmpl 0x8(%rdx), %ecx
jl 0x1a5e3
testq %rax, %rax
sete %al
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/supportSet.c
// Function: shallowCopySupportSet
struct SupportSet* shallowCopySupportSet(struct SupportSet* a) {
	struct SupportSet* copy = getSupportSet();
	copy->first = a->first;
	copy->last = a->last;
	copy->patternId = a->patternId;
	copy->size = a->size;
	return copy;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
callq 0x1a3dc
movups (%rbx), %xmm0
movups %xmm0, (%rax)
movl 0x20(%rbx), %ecx
movl %ecx, 0x20(%rax)
movq 0x18(%rbx), %rcx
movq %rcx, 0x18(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/supportSet.c
// Function: appendSupportSets
struct SupportSet* appendSupportSets(struct SupportSet* front, struct SupportSet* back) {
	struct SupportSet* tmp; 
	if (front) {
		for (tmp=front; tmp->next != NULL; tmp=tmp->next);
		tmp->next = back;
	} else {
		front = back;
	}
	return front;
}

// Assembly:
testq %rdi, %rdi
je 0x1a6d8
movq %rdi, %rax
movq %rdi, %rdx
movq %rdx, %rcx
movq 0x10(%rdx), %rdx
testq %rdx, %rdx
jne 0x1a6c7
movq %rsi, 0x10(%rcx)
retq
movq %rsi, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/supportSet.c
// Function: popSupportSet
struct SupportSet* popSupportSet(struct SupportSet** s) {
	struct SupportSet* head = (*s);
	(*s) = (*s)->next;
	head->next = NULL;
	return head;
}

// Assembly:
movq (%rdi), %rax
movq 0x10(%rax), %rcx
movq %rcx, (%rdi)
andq $0x0, 0x10(%rax)
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/treeCenter.c
// Function: _markEdges
int __markEdges(struct Vertex* root, int value) {
	struct VertexList* e;
	int max = value;

	root->lowPoint = value;

	for (e=root->neighborhood; e!=NULL; e=e->next) {
		if (e->endPoint->lowPoint > value) {
			/* __markEdges returns the depth of the subtree rooted at 
			e->endPoint */
			int current = __markEdges(e->endPoint, value + 1);
			e->used = current;

			if (current > max) {
				max = current;
			}
		}
	}
	/* return the maximum depth of any subtree rooted at root */
	return max;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movl %esi, 0x20(%rdi)
leal 0x1(%rbx), %r15d
movl %esi, %ebp
movq 0x8(%r14), %r14
testq %r14, %r14
je 0x1a726
movq 0x18(%r14), %rdi
cmpl %ebx, 0x20(%rdi)
jle 0x1a701
movl %r15d, %esi
callq 0x1a6ec
movl %eax, 0x20(%r14)
cmpl %ebp, %eax
cmovgl %eax, %ebp
jmp 0x1a701
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/treeCenter.c
// Function: _moveCenter
void __moveCenter(struct Vertex* root, struct Vertex* parent, int value, int depth, int* centers) {
	struct VertexList* e;
	int max = INT_MIN;
	struct VertexList* max1 = NULL;
	struct VertexList* max2 = NULL;

	/* update depths to fit to the new root */
	for (e=root->neighborhood; e!=NULL; e=e->next) {
		if (e->endPoint != parent) {
			e->used -= depth;
		} else {
			e->used = value;
		}
	}

	/* find maximum depth branch */
	for (e=root->neighborhood; e!=NULL; e=e->next) {
		if (e->used > max) {
			max = e->used;
			max1 = e;
		}
	}

	/* find second maximum depth branch */
	max = INT_MIN;
	for (e=root->neighborhood; e!=NULL; e=e->next) {
		if (e != max1) {
			if (e->used > max) {
				max = e->used;
				max2 = e;
			}
		}
	}

	/* if the current node is no leaf */
	if (max2 != NULL) {

		/* if the two deepest branches have same depth, we are at the 
		center */
		if (max1->used == max2->used) {
			centers[0] = 2;
			centers[1] = root->number;
			return;
		}

		/* this is the case where the longest path has odd length
		and we get two center nodes */
		if (max1->used == max2->used + 1) {
			centers[0] = 3;
			centers[1] = root->number;
			centers[2] = max1->endPoint->number;
			return;
		}
		/* ...and the symmetric case */
		if (max2->used == max1->used + 1) {
			centers[0] = 3;
			centers[1] = root->number;
			centers[2] = max2->endPoint->number;
			return;
		}

		/* move the center to the root of the deepest branch */
		__moveCenter(max1->endPoint, root, max2->used + 1, depth + 1, centers);
	} else {
		/* if we start at a leaf */
		__moveCenter(max1->endPoint, root, 1, 1, centers);
	}	
}

// Assembly:
pushq $0x1
popq %r9
movq %rdi, %rax
addq $0x8, %rdi
movq %rdi, %r10
movq (%r10), %r10
testq %r10, %r10
je 0x1a763
movl %edx, %r11d
cmpq %rsi, 0x18(%r10)
je 0x1a759
movl 0x20(%r10), %r11d
subl %ecx, %r11d
movl %r11d, 0x20(%r10)
addq $0x8, %r10
jmp 0x1a741
movl $0x80000000, %edx       # imm = 0x80000000
movq %rdi, %r10
xorl %esi, %esi
movq (%r10), %r10
testq %r10, %r10
je 0x1a78a
movl 0x20(%r10), %r11d
cmpl %edx, %r11d
cmovgl %r11d, %edx
cmovgq %r10, %rsi
addq $0x8, %r10
jmp 0x1a76d
movl $0x80000000, %edx       # imm = 0x80000000
xorl %r10d, %r10d
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x1a7b4
cmpq %rsi, %rdi
je 0x1a7ae
movl 0x20(%rdi), %r11d
cmpl %edx, %r11d
cmovgl %r11d, %edx
cmovgq %rdi, %r10
addq $0x8, %rdi
jmp 0x1a792
movl %r9d, %edx
movl %r9d, %r11d
testq %r10, %r10
je 0x1a7df
movl 0x20(%rsi), %edi
movl 0x20(%r10), %r11d
cmpl %r11d, %edi
je 0x1a7ee
leal 0x1(%r11), %edx
cmpl %edx, %edi
je 0x1a7f9
incl %edi
cmpl %edi, %r11d
je 0x1a80d
incl %ecx
movl %ecx, %r11d
movq 0x18(%rsi), %rdi
movq %rax, %rsi
movl %r11d, %ecx
jmp 0x1a737
movl $0x2, (%r8)
pushq $0x4
jmp 0x1a821
movl $0x3, (%r8)
movl 0x18(%rax), %eax
movl %eax, 0x4(%r8)
movq 0x18(%rsi), %rax
jmp 0x1a81f
movl $0x3, (%r8)
movl 0x18(%rax), %eax
movl %eax, 0x4(%r8)
movq 0x18(%r10), %rax
pushq $0x8
popq %rcx
movl 0x18(%rax), %eax
movl %eax, (%r8,%rcx)
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/treeCenter.c
// Function: treeCenter
int* treeCenter(struct Graph* tree) {
	int* centers = malloc(3 * sizeof(int));
	int i;

	if (tree->n < 3) {
		/* if the tree consists of one or two vertices, the
		center is clear (and the root-rebase algorithm does not work)
		*/
		if (tree->n == 1) {
			centers[0] = 2;
			centers[1] = 0;
		} else {
			centers[0] = 3;
			centers[1] = 0;
			centers[2] = 1;
		} /* zero vertex trees are not allowed */
	} else {
		/* init lowpoints and do the root-rebase algorithm
		starting from the first vertex we can get a hold of */
		for (i=0; i<tree->n; ++i) {
			tree->vertices[i]->lowPoint = INT_MAX;
		}
		__markEdges(tree->vertices[0], 0);
		__moveCenter(tree->vertices[0], tree->vertices[0] /*NULL*/, 0, 0, centers);	
	}
	return centers;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
pushq $0xc
popq %rdi
callq 0x1180
movq %rax, %rbx
movslq (%r14), %rax
cmpq $0x3, %rax
jge 0x1a853
cmpl $0x1, %eax
jne 0x1a894
movq $0x2, (%rbx)
jmp 0x1a8a2
movq 0x10(%r14), %rcx
xorl %edx, %edx
cmpq %rdx, %rax
je 0x1a86e
movq (%rcx,%rdx,8), %rsi
movl $0x7fffffff, 0x20(%rsi) # imm = 0x7FFFFFFF
incq %rdx
jmp 0x1a859
movq 0x10(%r14), %rax
movq (%rax), %rdi
xorl %esi, %esi
callq 0x1a6ec
movq 0x10(%r14), %rax
movq (%rax), %rdi
movq %rdi, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
movq %rbx, %r8
callq 0x1a733
jmp 0x1a8a2
movq $0x3, (%rbx)
movl $0x1, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/treeCenter.c
// Function: computeDistanceToCenter
int computeDistanceToCenter(struct Graph* g, struct ShallowGraphPool* sgp) {

	struct ShallowGraph* queue = getShallowGraph(sgp);

	// copmute tree center
	int* center = treeCenter(g);

	// clean the ->lowpoints
	for (int v=0; v<g->n; ++v) {
		g->vertices[v]->lowPoint = -1;
	}

	// init the queue with (bi)center
	for (int i=1; i<center[0]; ++i) {
		addToVertexQueue(g->vertices[center[i]], queue, sgp);
		g->vertices[center[i]]->lowPoint = 0;
	}
	free(center);

	// do bfs, mark vertices according to their distance to the (bi)center
	int depth = 0;
	for (struct Vertex* v=popFromVertexQueue(queue, sgp); v!=NULL; v=popFromVertexQueue(queue, sgp)) {
		depth = v->lowPoint + 1;
		for (struct VertexList* e=v->neighborhood; e!=NULL; e=e->next) {
			if (e->endPoint->lowPoint == -1) {
				e->endPoint->lowPoint = depth;
				addToVertexQueue(e->endPoint, queue, sgp);
			}
		}
	}
	dumpShallowGraph(sgp, queue);

	// depth is set too high by the last loop over the leaves in the outer shell
	return depth - 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movq %rsi, %rdi
callq 0x117e9
movq %rax, %r14
movq %r15, %rdi
callq 0x1a82a
movq %rax, (%rsp)
movl (%r15), %eax
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
cmpq %rcx, %rax
je 0x1a8f5
movq 0x10(%r15), %rdx
movq (%rdx,%rcx,8), %rdx
orl $-0x1, 0x20(%rdx)
incq %rcx
jmp 0x1a8df
movq (%rsp), %rax
movslq (%rax), %r13
pushq $0x1
popq %rbp
cmpq %r13, %rbp
jge 0x1a930
movq 0x10(%r15), %rax
movq (%rsp), %rcx
movslq (%rcx,%rbp,4), %r12
movq (%rax,%r12,8), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1ba70
movq 0x10(%r15), %rax
movq (%rax,%r12,8), %rax
andl $0x0, 0x20(%rax)
incq %rbp
jmp 0x1a8ff
movq (%rsp), %rdi
callq 0x1030
pushq $-0x1
popq %r15
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1ba99
testq %rax, %rax
je 0x1a97d
movq %rax, %r12
movl 0x20(%rax), %r15d
leal 0x1(%r15), %ebp
movq 0x8(%r12), %r12
testq %r12, %r12
je 0x1a93d
movq 0x18(%r12), %rdi
cmpl $-0x1, 0x20(%rdi)
jne 0x1a958
movl %ebp, 0x20(%rdi)
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1ba70
jmp 0x1a958
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1184e
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/treeEnumeration.c
// Function: refinementGraph
struct Graph* refinementGraph(struct Graph* g, int v, struct VertexList* newEdge, struct GraphPool* gp) {
	struct Graph* copy = getGraph(gp);
	int i;

	copy->activity = g->activity;
	copy->m = g->m; // addEdgebetweenVertices adds plus 1 itself
	copy->n = g->n + 1;
	copy->number = g->number;

	copy->vertices = malloc(copy->n * sizeof(struct Vertex*));

	/* copy vertices */
	for (i=0; i<g->n; ++i) {
		if (g->vertices[i]) {
			copy->vertices[i] = shallowCopyVertex(g->vertices[i], gp->vertexPool);
		}
	}

	/* copy new vertex and edge */
	copy->vertices[copy->n - 1] = shallowCopyVertex(newEdge->endPoint, gp->vertexPool);
	copy->vertices[copy->n - 1]->number = copy->n - 1;
	addEdgeBetweenVertices(v, copy->n - 1, newEdge->label, copy, gp);

	/* copy edges */
	for (i=0; i<g->n; ++i) {
		if (g->vertices[i]) {
			struct VertexList* e;
			for (e=g->vertices[i]->neighborhood; e; e=e->next) {
				struct VertexList* tmp = getVertexList(gp->listPool);
				tmp->endPoint = copy->vertices[e->endPoint->number];
				tmp->startPoint = copy->vertices[e->startPoint->number];
				tmp->label = e->label;

				/* add the shallow copy to the new graph */
				tmp->next = copy->vertices[e->startPoint->number]->neighborhood;
				copy->vertices[e->startPoint->number]->neighborhood = tmp;
			}
		}
	}
	return copy;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r12
movl %esi, %ebp
movq %rdi, %r14
movq %rcx, %rdi
callq 0x11619
movq %rax, %r15
movl 0xc(%r14), %eax
movl %eax, 0xc(%r15)
movslq (%r14), %rax
leaq 0x1(%rax), %rcx
movl %ecx, (%r15)
movq 0x4(%r14), %rcx
movq %rcx, 0x4(%r15)
leaq 0x8(,%rax,8), %rdi
callq 0x1180
movq %rax, 0x10(%r15)
xorl %r13d, %r13d
movslq (%r14), %rax
cmpq %rax, %r13
jge 0x1aa16
movq 0x10(%r14), %rax
movq (%rax,%r13,8), %rdi
testq %rdi, %rdi
je 0x1aa11
movq 0x10(%rbx), %rsi
callq 0x5a70
movq 0x10(%r15), %rcx
movq %rax, (%rcx,%r13,8)
incq %r13
jmp 0x1a9eb
movq 0x18(%r12), %rdi
movq 0x10(%rbx), %rsi
callq 0x5a70
movq 0x10(%r15), %rcx
movslq (%r15), %rsi
movq %rax, -0x8(%rcx,%rsi,8)
movq 0x10(%r15), %rax
movq -0x8(%rax,%rsi,8), %rax
decq %rsi
movl %esi, 0x18(%rax)
movq (%r12), %rdx
movl %ebp, %edi
movq %r15, %rcx
movq %rbx, %r8
callq 0x6200
xorl %r12d, %r12d
movslq (%r14), %rax
cmpq %rax, %r12
jge 0x1aac8
movq 0x10(%r14), %rax
movq (%rax,%r12,8), %r13
testq %r13, %r13
jne 0x1aaba
jmp 0x1aac3
movq 0x18(%rbx), %rdi
callq 0x11307
movq 0x10(%r15), %rcx
movq 0x18(%r13), %rdx
movslq 0x18(%rdx), %rdx
movq (%rcx,%rdx,8), %rdx
movq %rdx, 0x18(%rax)
movq 0x10(%r13), %rdx
movslq 0x18(%rdx), %rdx
movq (%rcx,%rdx,8), %rdx
movq %rdx, 0x10(%rax)
movq (%r13), %rdx
movq %rdx, (%rax)
movq 0x10(%r13), %rdx
movslq 0x18(%rdx), %rdx
movq (%rcx,%rdx,8), %rsi
movq 0x8(%rsi), %rsi
movq %rsi, 0x8(%rax)
movq (%rcx,%rdx,8), %rcx
movq %rax, 0x8(%rcx)
movq 0x8(%r13), %r13
testq %r13, %r13
jne 0x1aa6a
incq %r12
jmp 0x1aa53
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/treeEnumeration.c
// Function: extendPatternAllWays
struct Graph* extendPatternAllWays(struct Graph* g, struct ShallowGraph* candidateEdges, struct GraphPool* gp) {
	struct Graph* rho = NULL;
	struct VertexList* e;
	for (e=candidateEdges->edges; e!=NULL; e=e->next) {
		int v;
		for (v=0; v<g->n; ++v) {
			/* if the labels are compatible */
			if (strcmp(g->vertices[v]->label, e->startPoint->label) == 0) {
				struct Graph* h = refinementGraph(g, v, e, gp);
				h->next = rho;
				rho = h;
			}
		}
	}
	return rho;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
movq (%r14), %r14
testq %r14, %r14
je 0x1ab40
xorl %r13d, %r13d
movslq (%r15), %rax
cmpq %rax, %r13
jge 0x1ab3a
movq 0x10(%r15), %rax
movq (%rax,%r13,8), %rax
movq (%rax), %rdi
movq 0x10(%r14), %rax
movq (%rax), %rsi
callq 0x1130
testl %eax, %eax
jne 0x1ab35
movq %r15, %rdi
movl %r13d, %esi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x1a99c
movq %r12, 0x18(%rax)
movq %rax, %r12
incq %r13
jmp 0x1aafa
addq $0x8, %r14
jmp 0x1aaef
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/treeEnumeration.c
// Function: extendPatternOnLeaves
struct Graph* extendPatternOnLeaves(struct Graph* g, struct ShallowGraph* candidateEdges, struct GraphPool* gp) {

	struct Graph* rho = NULL;

	// init visited flags
	for (int v=0; v<g->n; ++v) {
		g->vertices[v]->visited = 0;
	}

	// mark leaves and neighbors of leaves
	for (int v=0; v<g->n; ++v) {
		if (isLeaf(g->vertices[v])) {
			g->vertices[v]->visited = 1;
			g->vertices[v]->neighborhood->endPoint->visited = 1;
		}
	}

	// special case: singleton vertex should be extended, as well (even though it is not a leaf)
	if (g->n == 1) {
		g->vertices[0]->visited = 1;
	}

	// add refinement edges only at leaves and neighbors of leaves
	for (int v=0; v<g->n; ++v) {
		if (g->vertices[v]->visited) {
			for (struct VertexList* e=candidateEdges->edges; e!=NULL; e=e->next) {
				/* if the labels are compatible */
				if (strcmp(g->vertices[v]->label, e->startPoint->label) == 0) {
					struct Graph* h = refinementGraph(g, v, e, gp);
					h->next = rho;
					rho = h;
				}
			}
		}
	}
	return rho;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl (%rdi), %eax
xorl %ecx, %ecx
testl %eax, %eax
movl $0x0, %edx
cmovgl %eax, %edx
cmpq %rcx, %rdx
je 0x1ab85
movq 0x10(%r15), %rsi
movq (%rsi,%rcx,8), %rsi
andl $0x0, 0x1c(%rsi)
incq %rcx
jmp 0x1ab6f
xorl %r12d, %r12d
pushq $0x1
popq %rbp
movslq %eax, %rcx
cmpq %rcx, %r12
jge 0x1abc2
movq 0x10(%r15), %rax
movq (%rax,%r12,8), %rdi
callq 0x5a99
testb %al, %al
je 0x1abba
movq 0x10(%r15), %rax
movq (%rax,%r12,8), %rax
movl %ebp, 0x1c(%rax)
movq 0x8(%rax), %rax
movq 0x18(%rax), %rax
movl %ebp, 0x1c(%rax)
incq %r12
movl (%r15), %eax
jmp 0x1ab8b
cmpl $0x1, %eax
jne 0x1abd5
movq 0x10(%r15), %rcx
movq (%rcx), %rcx
movl $0x1, 0x1c(%rcx)
xorl %r12d, %r12d
xorl %r13d, %r13d
movslq %eax, %rcx
cmpq %rcx, %r12
jge 0x1ac3e
movq 0x10(%r15), %rcx
movq (%rcx,%r12,8), %rcx
cmpl $0x0, 0x1c(%rcx)
je 0x1ac39
movq %r14, %rbp
movq (%rbp), %rbp
testq %rbp, %rbp
je 0x1ac36
movq 0x10(%r15), %rax
movq (%rax,%r12,8), %rax
movq (%rax), %rdi
movq 0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x1130
testl %eax, %eax
jne 0x1ac30
movq %r15, %rdi
movl %r12d, %esi
movq %rbp, %rdx
movq %rbx, %rcx
callq 0x1a99c
movq %r13, 0x18(%rax)
movq %rax, %r13
addq $0x8, %rbp
jmp 0x1abf4
movl (%r15), %eax
incq %r12
jmp 0x1abdb
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/treeEnumeration.c
// Function: extendPatternOnOuterShells
struct Graph* extendPatternOnOuterShells(struct Graph* g, struct ShallowGraph* candidateEdges, struct GraphPool* gp, struct ShallowGraphPool* sgp) {

	struct Graph* rho = NULL;

	// if v->lowPoint >= outershell then we extend on v
	int outerShell = computeDistanceToCenter(g, sgp) - 1;

	// add refinement edges only at outer shell vertices
	for (int v=0; v<g->n; ++v) {
		if (g->vertices[v]->lowPoint >= outerShell) {
			for (struct VertexList* e=candidateEdges->edges; e!=NULL; e=e->next) {
				/* if the labels are compatible */
				if (strcmp(g->vertices[v]->label, e->startPoint->label) == 0) {
					struct Graph* h = refinementGraph(g, v, e, gp);
					h->next = rho;
					rho = h;
				}
			}
		}
	}
	return rho;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, (%rsp)
movq %rdi, %r15
movq %rcx, %rsi
callq 0x1a8ad
movl %eax, %ebp
decl %ebp
xorl %r12d, %r12d
xorl %r13d, %r13d
movslq (%r15), %rax
cmpq %rax, %r12
jge 0x1acd6
movq 0x10(%r15), %rax
movq (%rax,%r12,8), %rax
cmpl %ebp, 0x20(%rax)
jge 0x1ac91
incq %r12
jmp 0x1ac77
movq (%rsp), %r14
movq (%r14), %r14
testq %r14, %r14
je 0x1ac8c
movq 0x10(%r15), %rax
movq (%rax,%r12,8), %rax
movq (%rax), %rdi
movq 0x10(%r14), %rax
movq (%rax), %rsi
callq 0x1130
testl %eax, %eax
jne 0x1acd0
movq %r15, %rdi
movl %r12d, %esi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x1a99c
movq %r13, 0x18(%rax)
movq %rax, %r13
addq $0x8, %r14
jmp 0x1ac95
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/treeEnumeration.c
// Function: basicFilter
struct Graph* basicFilter(struct Graph* extension, struct Vertex* listOfGraphs, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	struct Graph* result = NULL;
	struct Graph* g = extension;
	while (g != NULL) {
		// store second element, detach head
		struct Graph* tmp = g->next;
		g->next = NULL;

		struct ShallowGraph* string = canonicalStringOfTree(g, sgp);
		char alreadyFound = containsString(listOfGraphs, string);
		if (!alreadyFound) {
			addToSearchTree(listOfGraphs, string, gp, sgp);
			// add to result
			g->next = result;
			result = g;
		} else {
			dumpShallowGraph(sgp, string);
			dumpGraph(gp, g);
		}
		// move on
		g = tmp;
	}
	return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r13
movq $0x0, (%rsp)
movq %r13, %rbp
testq %r13, %r13
je 0x1ad6c
movq 0x18(%rbp), %r13
andq $0x0, 0x18(%rbp)
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x579f
movq %rax, %r12
movq %r15, %rdi
movq %rax, %rsi
callq 0x185c7
testb %al, %al
je 0x1ad4d
movq %rbx, %rdi
movq %r12, %rsi
callq 0x1184e
movq %r14, %rdi
movq %rbp, %rsi
callq 0x1166e
jmp 0x1ad07
movq %r15, %rdi
movq %r12, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x186c6
movq (%rsp), %rax
movq %rax, 0x18(%rbp)
movq %rbp, (%rsp)
jmp 0x1ad07
movq (%rsp), %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/treeEnumerationRooted.c
// Function: extendRootedPatternAllWays
struct Graph* extendRootedPatternAllWays(struct Graph* g, struct ShallowGraph* candidateEdges, struct GraphPool* gp) {
	struct Graph* rho = NULL;
	struct VertexList* e;
	for (e=candidateEdges->edges; e!=NULL; e=e->next) {
		int v;
		for (v=0; v<g->n; ++v) {
			/* if the labels are compatible */
			if (strcmp(g->vertices[v]->label, e->startPoint->label) == 0) {
				struct Graph* h = refinementGraph(g, v, e, gp);
				h->next = rho;
				rho = h;
			}
		}
	}
	return rho;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
xorl %r12d, %r12d
movq (%r14), %r14
testq %r14, %r14
je 0x1af7a
xorl %r13d, %r13d
movslq (%r15), %rax
cmpq %rax, %r13
jge 0x1af74
movq 0x10(%r15), %rax
movq (%rax,%r13,8), %rax
movq (%rax), %rdi
movq 0x10(%r14), %rax
movq (%rax), %rsi
callq 0x1130
testl %eax, %eax
jne 0x1af6f
movq %r15, %rdi
movl %r13d, %esi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x1a99c
movq %r12, 0x18(%rax)
movq %rax, %r12
incq %r13
jmp 0x1af34
addq $0x8, %r14
jmp 0x1af29
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/treeKernels.c
// Function: cleanUpEdgeSort
void cleanUpEdgeSort(struct Vertex* v, struct ShallowGraphPool* sgp) {
	struct VertexList* e;
	struct VertexList* f;
	struct VertexList* first = getVertexList(sgp->listPool);
	struct ShallowGraph* fifo = getShallowGraph(sgp);

	/* create artificial edge to start bfs */
	first->endPoint = v;
	first->startPoint = v;
	appendEdge(fifo, first);

	/* bfs */
	while((e = popEdge(fifo))) {


			/* store distance */
			e->endPoint->visited = 0;

			/* put children in fifo queue */
			for (f=e->endPoint->neighborhood; f; f = f->next) {
				if (f->endPoint->visited) {
					appendEdge(fifo, shallowCopyEdge(f, sgp->listPool));
				}
			}

			dumpVertexList(sgp->listPool, e);

	}

	dumpShallowGraph(sgp, fifo);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movq 0x10(%rsi), %rdi
callq 0x11307
movq %rax, %r12
movq %rbx, %rdi
callq 0x117e9
movq %rax, %r14
movq %r15, 0x18(%r12)
movq %r15, 0x10(%r12)
movq %rax, %rdi
movq %r12, %rsi
callq 0x6620
movq %r14, %rdi
callq 0x65fe
testq %rax, %rax
je 0x1b1b4
movq %rax, %r15
movq 0x18(%rax), %r12
andl $0x0, 0x1c(%r12)
movq 0x8(%r12), %r12
testq %r12, %r12
je 0x1b1a6
movq 0x18(%r12), %rax
cmpl $0x0, 0x1c(%rax)
je 0x1b178
movq 0x10(%rbx), %rsi
movq %r12, %rdi
callq 0x5a28
movq %r14, %rdi
movq %rax, %rsi
callq 0x6620
jmp 0x1b178
movq 0x10(%rbx), %rdi
movq %r15, %rsi
callq 0x11364
jmp 0x1b15e
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1184e
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/treeKernels.c
// Function: edgeSort
struct ShallowGraph* edgeSort(struct Vertex* v, int maxDepth, struct ShallowGraphPool* sgp) {
	struct VertexList* e;
	struct VertexList* f;
	struct VertexList* first = getVertexList(sgp->listPool);
	struct ShallowGraph* output = getShallowGraph(sgp);
	struct ShallowGraph* fifo = getShallowGraph(sgp);

	/* create artificial edge to start bfs */
	first->endPoint = v;
	first->startPoint = v;
	appendEdge(fifo, first);

	/* bfs */
	while((e = popEdge(fifo))) {

		/* breaking condition */
		if (e->startPoint->visited > maxDepth) {
			dumpVertexList(sgp->listPool, e);
			break;
		}

		/* store distance */
		e->endPoint->visited = e->startPoint->visited + 1;
		appendEdge(output, e);

		/* put children in fifo queue */
		for (f=e->endPoint->neighborhood; f; f = f->next) {
			if (f->endPoint->visited == 0) {
				appendEdge(fifo, shallowCopyEdge(f, sgp->listPool));
			}
		}
	}

	dumpShallowGraph(sgp, fifo);

	return output;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r12
movq 0x10(%rdx), %rdi
callq 0x11307
movq %rax, %r13
movq %rbx, %rdi
callq 0x117e9
movq %rax, %r14
movq %rbx, %rdi
callq 0x117e9
movq %rax, %r15
movq %r12, 0x18(%r13)
movq %r12, 0x10(%r13)
movq %rax, %rdi
movq %r13, %rsi
callq 0x6620
movq %r15, %rdi
callq 0x65fe
testq %rax, %rax
je 0x1b281
movq %rax, %r12
movq 0x10(%rax), %rax
movl 0x1c(%rax), %eax
cmpl %ebp, %eax
jg 0x1b275
incl %eax
movq 0x18(%r12), %rcx
movl %eax, 0x1c(%rcx)
movq %r14, %rdi
movq %r12, %rsi
callq 0x6620
movq 0x18(%r12), %r12
movq 0x8(%r12), %r12
testq %r12, %r12
je 0x1b212
movq 0x18(%r12), %rax
cmpl $0x0, 0x1c(%rax)
jne 0x1b247
movq 0x10(%rbx), %rsi
movq %r12, %rdi
callq 0x5a28
movq %r15, %rdi
movq %rax, %rsi
callq 0x6620
jmp 0x1b247
movq 0x10(%rbx), %rdi
movq %r12, %rsi
callq 0x11364
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1184e
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/treeKernels.c
// Function: bfsSubtreeEnumeration
struct ShallowGraph* bfsSubtreeEnumeration(struct Graph* t, int maxDepth, struct ShallowGraphPool* sgp) {
	int i;
	struct ShallowGraph* results = NULL;

	for (i=0; i<t->n; ++i) {
		if (t->vertices[i]) {

			int j;
			struct ShallowGraph* sorted = edgeSort(t->vertices[i], maxDepth, sgp);

			/* if maxDepth is too large, the for loop below will return
			 * multiple copies of the largest level tree. */
			if (maxDepth > sorted->lastEdge->endPoint->visited) {
				maxDepth = sorted->lastEdge->endPoint->visited;
			}

			/* compute and store canonical string of the tree rooted at v for each level
			 * TODO This can change. Maybe compute canonical string for free tree... */
			for (j=1; j<=maxDepth; ++j) {
				struct ShallowGraph* level = canonicalStringOfRootedLevelTree(t->vertices[i], NULL, j, sgp);
				level->next = results;
				results = level;
			}

			cleanUpEdgeSort(t->vertices[i], sgp);
			dumpShallowGraph(sgp, sorted);
		}
	}
	return results;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movl %esi, %r13d
movq %rdi, %r14
xorl %r12d, %r12d
xorl %r15d, %r15d
movslq (%r14), %rax
cmpq %rax, %r12
jge 0x1b359
movq 0x10(%r14), %rax
movq (%rax,%r12,8), %rdi
testq %rdi, %rdi
je 0x1b351
movl %r13d, %esi
movq %rbx, %rdx
callq 0x1b1ca
movq %rax, 0x10(%rsp)
movq 0x8(%rax), %rax
movq 0x18(%rax), %rax
movl 0x1c(%rax), %eax
cmpl %eax, %r13d
cmovll %r13d, %eax
testl %eax, %eax
movl $0x0, %ebp
movl %eax, 0xc(%rsp)
cmovgl %eax, %ebp
negl %ebp
pushq $0x1
popq %rax
movl %eax, %r13d
leal (%rbp,%r13), %eax
movq 0x10(%r14), %rcx
movq (%rcx,%r12,8), %rdi
cmpl $0x1, %eax
je 0x1b337
xorl %esi, %esi
movl %r13d, %edx
movq %rbx, %rcx
callq 0x5401
movq %r15, 0x18(%rax)
incl %r13d
movq %rax, %r15
jmp 0x1b30c
movq %rbx, %rsi
callq 0x1b124
movq %rbx, %rdi
movq 0x10(%rsp), %rsi
callq 0x1184e
movl 0xc(%rsp), %r13d
incq %r12
jmp 0x1b2bb
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/treeKernels.c
// Function: fullSubtreeEnumeration
int fullSubtreeEnumeration(struct Graph* t, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	int numberOfTrees = 0;

	/* get initially empty list of forbidden edges and E(t) */
	struct ShallowGraph* allEdges = getGraphEdges(t, sgp);
	struct ShallowGraph* forbiddenEdges = getShallowGraph(sgp);

	/* create $ current = (V(t), \emptyset) $ */
	struct Graph* current = getGraph(gp);
	int i;
	setVertexNumber(current, t->n);
	for (i=0; i<t->n; ++i) {
		current->vertices[i] = shallowCopyVertex(t->vertices[i], gp->vertexPool);
	}

	recSubtreeEnum(current, forbiddenEdges, allEdges, &numberOfTrees, sgp);


	/* garbage collection */
	dumpShallowGraph(sgp, allEdges);
	dumpShallowGraph(sgp, forbiddenEdges);
	dumpGraph(gp, current);

	return numberOfTrees;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %rbp
andl $0x0, 0xc(%rsp)
movq %rdx, %rsi
callq 0x6172
movq %rax, 0x10(%rsp)
movq %r14, %rdi
callq 0x117e9
movq %rax, %r12
movq %rbx, %rdi
callq 0x11619
movq %rax, %r13
movl (%rbp), %esi
movq %rax, %rdi
callq 0x5c80
xorl %r15d, %r15d
movslq (%rbp), %rax
cmpq %rax, %r15
jge 0x1b670
movq 0x10(%rbp), %rax
movq (%rax,%r15,8), %rdi
movq 0x10(%rbx), %rsi
callq 0x5a70
movq 0x10(%r13), %rcx
movq %rax, (%rcx,%r15,8)
incq %r15
jmp 0x1b649
leaq 0xc(%rsp), %rbp
movq %r13, %rdi
movq %r12, %rsi
movq 0x10(%rsp), %r15
movq %r15, %rdx
movq %rbp, %rcx
movq %r14, %r8
callq 0x1b44b
movq %r14, %rdi
movq %r15, %rsi
callq 0x1184e
movq %r14, %rdi
movq %r12, %rsi
callq 0x1184e
movq %rbx, %rdi
movq %r13, %rsi
callq 0x1166e
movl (%rbp), %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/upperBoundsForSpanningTrees.c
// Function: nCr
long nCr(long n, long r) {
	long numer = 1;
	long denom = 1;
	int i;
	if (n - r < r) {
		r = n - r;
	}
	if (r == 0) {
		return 1;
	}
	for (i=n; i>n-r; --i) {
		numer *= i;
	}
	for (i=1; i<r+1; ++i) {
		denom *= i;
	}
	return numer / denom;
}

// Assembly:
movq %rdi, %rcx
subq %rsi, %rcx
cmpq %rsi, %rcx
cmovgeq %rsi, %rcx
testq %rcx, %rcx
je 0x1b71b
movq %rdi, %rdx
subq %rcx, %rdx
movslq %edi, %rsi
pushq $0x1
popq %rax
cmpq %rsi, %rdx
jge 0x1b6f0
imulq %rsi, %rax
decq %rsi
jmp 0x1b6e2
xorl %edx, %edx
testq %rcx, %rcx
cmovgq %rcx, %rdx
negq %rdx
pushq $0x1
popq %rsi
movq %rsi, %rcx
leaq (%rdx,%rsi), %rdi
cmpq $0x1, %rdi
je 0x1b715
imulq %rsi, %rcx
incq %rsi
jmp 0x1b702
cqto
idivq %rcx
retq
pushq $0x1
popq %rax
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/upperBoundsForSpanningTrees.c
// Function: nCr2
long nCr2(long n, long r) {
	long numer = 1;
	long denom = 1;
	int i;
	if (n - r < r) {
		r = n - r;
	}
	if (r == 0) {
		return 1;
	}
	for (i=n; i>n-r; --i) {
		/* avoid overflowing */
		if (numer >= LONG_MAX / i) {
			return -1;
		}
		numer *= i;
	}
	/* r! is always smaller than (n-r)*...*(r+1) */
	for (i=1; i<r+1; ++i) {
		denom *= i;
	}
	return numer / denom;
}

// Assembly:
movq %rdi, %r8
subq %rsi, %r8
cmpq %rsi, %r8
cmovgeq %rsi, %r8
testq %r8, %r8
je 0x1b765
movq %rdi, %r9
subq %r8, %r9
movslq %edi, %r10
pushq $0x1
popq %rcx
movabsq $0x7fffffffffffffff, %rdi # imm = 0x7FFFFFFFFFFFFFFF
pushq $-0x1
popq %rsi
cmpq %r10, %r9
jge 0x1b76a
movq %rdi, %rax
xorl %edx, %edx
idivq %r10
cmpq %rax, %rcx
jge 0x1b79a
imulq %r10, %rcx
decq %r10
jmp 0x1b74a
pushq $0x1
popq %rsi
jmp 0x1b79a
xorl %eax, %eax
testq %r8, %r8
cmovgq %r8, %rax
negq %rax
pushq $0x1
popq %rdx
movq %rdx, %rsi
leaq (%rax,%rdx), %rdi
cmpq $0x1, %rdi
je 0x1b78f
imulq %rdx, %rsi
incq %rdx
jmp 0x1b77c
movq %rcx, %rax
cqto
idivq %rsi
movq %rax, %rsi
movq %rsi, %rax
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/upperBoundsForSpanningTrees.c
// Function: outerplanarBound
long outerplanarBound(long m, long n) {
	double estimate = 0.0;
	long i;
	long k = m-n;
	for (i=0; i<k+1; ++i) {
		double mean = n / (double)(i+1);
		double meanPot = 1.0;
		int j;
		long bin;

		for (j=0; j<i+1; ++j) {
			meanPot *= mean;
		}

		if (meanPot >= DBL_MAX) {
			return (long)-1;
		}
		
		bin = nCr2(k, i);
		if (bin < 0) {
			/* there was an overflow in nCr2 */
			return (long)-1;
		} else {
			estimate += bin * meanPot;
		}
	}
	if (estimate > LONG_MAX) {
		return (unsigned long)-1;
	} else {
		return (unsigned long)estimate;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
subq %rsi, %r14
cvtsi2sd %rsi, %xmm0
movsd %xmm0, (%rsp)
xorpd %xmm2, %xmm2
pushq $0x1
popq %r15
xorl %esi, %esi
pushq $-0x1
popq %rbx
cmpq %r14, %rsi
jg 0x1b83c
leaq 0x1(%rsi), %r12
cvtsi2sd %r12, %xmm1
movsd (%rsp), %xmm0
divsd %xmm1, %xmm0
movq %r15, %rax
movsd 0x2518(%rip), %xmm1     # 0x1dd08
subq $0x1, %rax
jb 0x1b7fc
mulsd %xmm0, %xmm1
jmp 0x1b7f0
ucomisd 0x286c(%rip), %xmm1     # 0x1e070
jae 0x1b865
movsd %xmm1, 0x8(%rsp)
movapd %xmm2, 0x10(%rsp)
movq %r14, %rdi
callq 0x1b71f
testq %rax, %rax
js 0x1b865
cvtsi2sd %rax, %xmm0
mulsd 0x8(%rsp), %xmm0
movapd 0x10(%rsp), %xmm2
addsd %xmm0, %xmm2
incq %r15
movq %r12, %rsi
jmp 0x1b7ce
ucomisd 0x2834(%rip), %xmm2     # 0x1e078
ja 0x1b865
cvttsd2si %xmm2, %rax
movq %rax, %rcx
sarq $0x3f, %rcx
subsd 0x281e(%rip), %xmm2     # 0x1e078
cvttsd2si %xmm2, %rbx
andq %rcx, %rbx
orq %rax, %rbx
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/upperBoundsForSpanningTrees.c
// Function: getVertexNumberOfInducedGraph
int getVertexNumberOfInducedGraph(struct ShallowGraph* g, int n, int* vertices) {
	int i;
	struct VertexList* e;
	int nInd = 0;
	for(i=0; i<n; ++i) { vertices[i] = 0; }
	for(e=g->edges; e!=NULL; e=e->next) {
		vertices[e->startPoint->number] = 1;
		vertices[e->endPoint->number] = 1;
	}
	for (i=0; i<n; ++i) {
		if (vertices[i] != 0) {
			++nInd;
		}
	}
	return nInd;
}

// Assembly:
xorl %eax, %eax
testl %esi, %esi
cmovlel %eax, %esi
cmpq %rax, %rsi
je 0x1b889
andl $0x0, (%rdx,%rax,4)
incq %rax
jmp 0x1b87b
pushq $0x1
popq %rax
movq (%rdi), %rdi
testq %rdi, %rdi
je 0x1b8b0
movq 0x10(%rdi), %rcx
movslq 0x18(%rcx), %rcx
movl %eax, (%rdx,%rcx,4)
movq 0x18(%rdi), %rcx
movslq 0x18(%rcx), %rcx
movl %eax, (%rdx,%rcx,4)
addq $0x8, %rdi
jmp 0x1b88c
xorl %ecx, %ecx
xorl %eax, %eax
cmpq %rcx, %rsi
je 0x1b8c5
cmpl $0x1, (%rdx,%rcx,4)
sbbl $-0x1, %eax
incq %rcx
jmp 0x1b8b4
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/upperBoundsForSpanningTrees.c
// Function: getGoodEstimate
long int getGoodEstimate(struct Graph* g, struct ShallowGraphPool* sgp, struct GraphPool* gp) {
	struct ShallowGraph* biconnectedComponents = listBiconnectedComponents(g, sgp);
	long int estimate = getGoodEstimatePrecomputedBlocks(g, biconnectedComponents, sgp, gp);
	dumpShallowGraphCycle(sgp, biconnectedComponents);
	return estimate;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0x8ccd
movq %rax, %r12
movq %r15, %rdi
movq %rax, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x1b90d
movq %rax, %rbx
movq %r14, %rdi
movq %r12, %rsi
callq 0x11888
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/upperBoundsForSpanningTrees.c
// Function: getGoodEstimatePrecomputedBlocks
long int getGoodEstimatePrecomputedBlocks(struct Graph* g, struct ShallowGraph* biconnectedComponents, struct ShallowGraphPool* sgp, struct GraphPool* gp) {
	struct ShallowGraph* idx;
	long estimate = 1;
	int* vertices = malloc(g->n * sizeof(int));

	for (idx=biconnectedComponents; idx!=NULL; idx=idx->next) {
		if (idx->m != 1) {
			int nInd = getVertexNumberOfInducedGraph(idx, g->n, vertices);
			if (!isOuterplanarBlockShallow(idx, sgp, gp)) {
				long bound = trivialBound(idx->m, nInd);
				if (bound == -1){
					free(vertices);
					return -1;
				} else {
					estimate *= bound;
				}
			} else {
				long bound = outerplanarBound(idx->m, nInd);
				if (bound == -1) {
					free(vertices);
					return -1;
				} else {
					estimate *= bound;
				}
			}
		} else {
			/* Biconnected Component idx is a bridge. Computation would be:
			estimate *= 1;
			However, we do not want to waste time doing nothing */
		}
	}
	free(vertices);
	return estimate;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, (%rsp)
movq %rdx, %r12
movq %rsi, %r13
movq %rdi, %rbp
movslq (%rdi), %rdi
shlq $0x2, %rdi
callq 0x1180
movq %rax, %rbx
pushq $0x1
popq %r14
testq %r13, %r13
je 0x1b98f
cmpl $0x1, 0x10(%r13)
je 0x1b985
movl (%rbp), %esi
movq %r13, %rdi
movq %rbx, %rdx
callq 0x1b874
movl %eax, %r15d
movq %r13, %rdi
movq %r12, %rsi
movq (%rsp), %rdx
callq 0x13e70
movslq 0x10(%r13), %rdi
movslq %r15d, %rsi
testb %al, %al
je 0x1b976
callq 0x1b7a6
jmp 0x1b97b
callq 0x1b79e
cmpq $-0x1, %rax
je 0x1b98b
imulq %rax, %r14
movq 0x18(%r13), %r13
jmp 0x1b938
pushq $-0x1
popq %r14
movq %rbx, %rdi
callq 0x1030
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/upperBoundsForSpanningTrees.c
// Function: getEstimate
long int getEstimate(struct Graph* g, long int estimateFunction(long int, long int), char checkOuterplanarity, struct ShallowGraphPool* sgp, struct GraphPool* gp) {
	struct ShallowGraph* biconnectedComponents = listBiconnectedComponents(g, sgp);
	struct ShallowGraph* idx;
	long int estimate = 1;
	int* vertices = malloc(g->n * sizeof(int));

	for (idx=biconnectedComponents; idx!=NULL; idx=idx->next) {
		if (idx->m != 1) {
			int nInd;
			if (checkOuterplanarity) {
				if (!isOuterplanarBlockShallow(idx, sgp, gp)) {
					dumpShallowGraphCycle(sgp, biconnectedComponents);
					return -1;
				} else {
					
				}

			}
			nInd = getVertexNumberOfInducedGraph(idx, g->n, vertices);
			/* printf("(%li %i %i) ", estimateFunction(idx->m, nInd), nInd, idx->m); */
			estimate *= estimateFunction(idx->m, nInd);
		}
	}

	dumpShallowGraphCycle(sgp, biconnectedComponents);
	free(vertices);
	return estimate;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, 0x10(%rsp)
movl %edx, %ebp
movq %rsi, %r15
movq %rdi, %r12
movq %rcx, (%rsp)
movq %rcx, %rsi
callq 0x8ccd
movq %rax, %rbx
movslq (%r12), %rdi
shlq $0x2, %rdi
callq 0x1180
movq %rax, %r14
pushq $0x1
popq %r13
movq %rbx, 0x8(%rsp)
testq %rbx, %rbx
je 0x1ba34
cmpl $0x1, 0x10(%rbx)
je 0x1ba2e
testb %bpl, %bpl
je 0x1ba11
movq %rbx, %rdi
movq (%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x13e70
testb %al, %al
je 0x1ba4c
movl (%r12), %esi
movq %rbx, %rdi
movq %r14, %rdx
callq 0x1b874
movslq 0x10(%rbx), %rdi
movslq %eax, %rsi
callq *%r15
imulq %rax, %r13
movq 0x18(%rbx), %rbx
jmp 0x1b9ec
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x11888
movq %r14, %rdi
callq 0x1030
jmp 0x1ba5e
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x11888
pushq $-0x1
popq %r13
movq %r13, %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/vertexQueue.c
// Function: popFromVertexQueue
struct Vertex* popFromVertexQueue(struct ShallowGraph* queue, struct ShallowGraphPool* sgp) {
	struct VertexList* e = popEdge(queue);
	if (e != NULL) {
		struct Vertex* v = e->endPoint;
		dumpVertexList(sgp->listPool, e);
		return v;
	} else {
		return NULL;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
callq 0x65fe
testq %rax, %rax
je 0x1babc
movq 0x18(%rax), %rbx
movq 0x10(%r14), %rdi
movq %rax, %rsi
callq 0x11364
jmp 0x1babe
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/weisfeilerLehman.c
// Function: getWLLabel
char* getWLLabel(struct Vertex* v, struct Vertex* trie, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	char* resultingLabel;
	struct Vertex* local = getVertex(gp->vertexPool);
	struct ShallowGraph* string = getShallowGraph(sgp);
	struct ShallowGraph* copy;
	int deg = degree(v);
	char** neighborlabels = malloc(deg * sizeof(char*));
	int i = 0;
	struct VertexList* e;

	for (e=v->neighborhood; e!=NULL; e=e->next) {
		neighborlabels[i] = e->endPoint->label;
		++i;
	}
	qsort(neighborlabels, deg, sizeof(char*), &compare);

	e = getVertexList(sgp->listPool);
	e->label = v->label;
	appendEdge(string, e);
	for (i=0; i<deg; ++i) {
		e = getVertexList(sgp->listPool);
		e->label = neighborlabels[i];
		appendEdge(string, e);
	}
	// fprintf(stderr, "adding string ");
	// printCanonicalString(string, stdout);
	copy = cloneShallowGraph(string, sgp);
	// fprintf(stderr, "copy          ");
	// printCanonicalString(copy, stdout);
	addToSearchTree(local, copy, gp, sgp);
	mergeSearchTrees(trie, local, 1, NULL, 0, trie, 0, gp);
	i = getID(trie, string);
	// fprintf(stderr, "resulting label %i\n", i);
	resultingLabel = intLabel(i);
	dumpShallowGraphCycle(sgp, string);
	free(neighborlabels);
	return resultingLabel;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rcx, %rbx
movq %rdx, %r13
movq %rsi, 0x20(%rsp)
movq %rdi, %r14
movq 0x10(%rdx), %rdi
callq 0x114a5
movq %rax, 0x18(%rsp)
movq %rbx, %rdi
callq 0x117e9
movq %rax, %r15
movq %r14, %rdi
callq 0x5a8a
movslq %eax, %rbp
leaq (,%rbp,8), %rdi
callq 0x1180
movq %rax, %r12
movq %r14, %rcx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x1bb48
movq 0x18(%rcx), %rdx
movq (%rdx), %rdx
movq %rdx, (%rax)
addq $0x8, %rax
jmp 0x1bb2f
leaq 0xd5(%rip), %rcx        # 0x1bc24
pushq $0x8
popq %rdx
movq %r12, %rdi
movq %rbp, %rsi
callq 0x1080
movq 0x10(%rbx), %rdi
callq 0x11307
movq (%r14), %rcx
movq %rcx, (%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0x6620
xorl %r14d, %r14d
testl %ebp, %ebp
cmovlel %r14d, %ebp
cmpq %r14, %rbp
je 0x1bba5
movq 0x10(%rbx), %rdi
callq 0x11307
movq (%r12,%r14,8), %rcx
movq %rcx, (%rax)
movq %r15, %rdi
movq %rax, %rsi
callq 0x6620
incq %r14
jmp 0x1bb80
movq %r15, %rdi
movq %rbx, %rsi
callq 0x659e
movq 0x18(%rsp), %rbp
movq %rbp, %rdi
movq %rax, %rsi
movq %r13, %rdx
movq %rbx, %rcx
callq 0x186c6
andl $0x0, (%rsp)
movq %r13, 0x8(%rsp)
pushq $0x1
popq %rdx
movq 0x20(%rsp), %r14
movq %r14, %rdi
movq %rbp, %rsi
xorl %ecx, %ecx
xorl %r8d, %r8d
movq %r14, %r9
callq 0x1877e
movq %r14, %rdi
movq %r15, %rsi
callq 0x1860a
movl %eax, %edi
callq 0xb405
movq %rax, %r14
movq %rbx, %rdi
movq %r15, %rsi
callq 0x11888
movq %r12, %rdi
callq 0x1030
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq