LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/iterativeSubtreeIsomorphism.c
// Function: computeCharacteristic
int computeCharacteristic(struct SubtreeIsoDataStore data, struct Vertex* y, struct Vertex* u, struct Vertex* v, struct GraphPool* gp) {
	// TODO speedup by handling leaf case separately
	struct Graph* B = makeBipartiteInstanceFromVertices(data, y, u, v, gp);
	int sizeofMatching = bipartiteMatchingEvenMoreDirty(B);

	int nNeighbors = B->number;
	dumpGraph(gp, B);
	return (sizeofMatching == nNeighbors) ? 1 : 0;
}

// Assembly:
subq $0x58, %rsp
leaq 0x60(%rsp), %r8
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x40(%rsp), %rdx
movq 0x38(%rsp), %rcx
movq 0x20(%r8), %r9
movq %rsp, %rax
movq %r9, 0x20(%rax)
movups (%r8), %xmm0
movups 0x10(%r8), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0xe600
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0x21d0
movl %eax, 0x2c(%rsp)
movq 0x30(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x28(%rsp)
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x1fb30
movl 0x2c(%rsp), %edx
movl 0x28(%rsp), %esi
xorl %eax, %eax
movl $0x1, %ecx
cmpl %esi, %edx
cmovel %ecx, %eax
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/iterativeSubtreeIsomorphism.c
// Function: computeCharacteristicCached
int computeCharacteristicCached(struct SubtreeIsoDataStore data, struct CachedGraph* cachedB, struct Vertex* y, struct Vertex* u, struct Vertex* v, struct GraphPool* gp) {
	struct Graph* B = makeBipartiteInstanceFromVerticesCached(data, cachedB, y, u, v, gp);
	char hasMatchingCoveringAll = bipartiteMatchingTerminateEarly(B);
	returnCachedGraph(cachedB);
	return hasMatchingCoveringAll;
}

// Assembly:
subq $0x68, %rsp
leaq 0x70(%rsp), %r9
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x40(%rsp)
movq 0x60(%rsp), %rdi
movq 0x58(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq 0x48(%rsp), %rcx
movq 0x40(%rsp), %r8
movq 0x20(%r9), %r10
movq %rsp, %rax
movq %r10, 0x20(%rax)
movups (%r9), %xmm0
movups 0x10(%r9), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0xe9a0
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0x22f0
movb %al, 0x37(%rsp)
movq 0x60(%rsp), %rdi
callq 0x2d10
movsbl 0x37(%rsp), %eax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/iterativeSubtreeIsomorphism.c
// Function: getParentsFromPostorder
int* getParentsFromPostorder(struct Graph* g, int* postorder) {
	int* parents = malloc(g->n * sizeof(int));
	for (int i=0; i<g->n; ++i) {
		int v = postorder[i];
		parents[v] = g->vertices[v]->lowPoint;
	}
	return parents;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movslq (%rax), %rdi
shlq $0x2, %rdi
callq 0x1170
movq %rax, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl (%rcx), %eax
jge 0xed49
movq 0x18(%rsp), %rax
movslq 0xc(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movl 0x20(%rax), %edx
movq 0x10(%rsp), %rax
movslq 0x8(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0xecfc
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/iterativeSubtreeIsomorphism.c
// Function: getParents
int* getParents(struct Graph* g, int root) {
	int* postorder = getPostorder(g, root);
	int* parents = getParentsFromPostorder(g, postorder);
	free(postorder);
	return parents;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %esi
callq 0x2df00
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xecd0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
callq 0x1030
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/iterativeSubtreeIsomorphism.c
// Function: iterativeSubtreeCheck
struct SubtreeIsoDataStore iterativeSubtreeCheck(struct SubtreeIsoDataStore base, struct Graph* h, struct GraphPool* gp) {
	struct SubtreeIsoDataStore info = {0};
	info.g = base.g;
	info.h = h;
	info.postorder = base.postorder;

	createNewCubeFromBase(base, &info);
	iterativeSubtreeCheck_intern(base, &info, gp);

	return info;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x38(%rsp)
movq %rdi, %rax
movq %rax, 0x40(%rsp)
leaq 0x60(%rsp), %rax
movq %rax, 0x30(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
xorl %esi, %esi
movl $0x28, %edx
callq 0x10b0
movq 0x30(%rsp), %rcx
movq 0x38(%rsp), %rdi
movq 0x8(%rcx), %rax
movq %rax, 0x8(%rdi)
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rdi)
movq (%rcx), %rax
movq %rax, (%rdi)
movq 0x20(%rcx), %rdx
movq %rsp, %rax
movq %rdx, 0x20(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x22f70
movq 0x30(%rsp), %rcx
movq 0x38(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x20(%rcx), %rdx
movq %rsp, %rax
movq %rdx, 0x20(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0xee60
movq 0x40(%rsp), %rax
addq $0x58, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/iterativeSubtreeIsomorphism.c
// Function: initG
struct SubtreeIsoDataStore initG(struct Graph* g) {
	struct SubtreeIsoDataStore info = {0};
	info.postorder = getPostorder(g, 0);
	info.g = g;
	return info;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, (%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
xorl %esi, %esi
movl $0x28, %edx
callq 0x10b0
movq 0x10(%rsp), %rdi
xorl %esi, %esi
callq 0x2df00
movq (%rsp), %rdi
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rdi)
movq 0x10(%rsp), %rcx
movq %rcx, 0x8(%rdi)
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/iterativeSubtreeIsomorphism.c
// Function: initIterativeSubtreeCheckForSingleton
struct SubtreeIsoDataStore initIterativeSubtreeCheckForSingleton(struct SubtreeIsoDataStore base, struct Graph* h) {
	struct SubtreeIsoDataStore info = {0};
	// copy stuff from below
	info.g = base.g;
	info.postorder = base.postorder;
	info.h = h;

	struct Vertex* u = h->vertices[0];
	char* uLabel = u->label;

	// create cube
	createNewCubeForSingletonPattern(&info);

	for (int vi=0; vi<(info.g)->n; ++vi) {
		struct Vertex* v = (info.g)->vertices[info.postorder[vi]];

		if (labelCmp(v->label, uLabel) == 0) {
			// if vertex labels match, there is a characteristic (H^y_u, v)
			addCharacteristic(&info, u, u, v);
			info.foundIso = 1;
		}
	}

	return info;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
leaq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movq %rsi, 0x40(%rsp)
xorl %esi, %esi
movl $0x28, %edx
callq 0x10b0
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rdi
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rdi)
movq (%rax), %rax
movq %rax, (%rdi)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rdi)
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x30(%rsp)
callq 0x22f10
movl $0x0, 0x2c(%rsp)
movq 0x18(%rsp), %rcx
movl 0x2c(%rsp), %eax
movq 0x8(%rcx), %rcx
cmpl (%rcx), %eax
jge 0xf726
movq 0x18(%rsp), %rcx
movq 0x8(%rcx), %rax
movq 0x10(%rax), %rax
movq (%rcx), %rcx
movslq 0x2c(%rsp), %rdx
movslq (%rcx,%rdx,4), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rdi
movq 0x30(%rsp), %rsi
callq 0x2dcf0
cmpl $0x0, %eax
jne 0xf717
movq 0x18(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x38(%rsp), %rdx
movq 0x20(%rsp), %rcx
callq 0x23040
movq 0x18(%rsp), %rax
movl $0x1, 0x20(%rax)
jmp 0xf719
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0xf6a8
movq 0x8(%rsp), %rax
addq $0x48, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/iterativeSubtreeIsomorphism.c
// Function: initIterativeSubtreeCheck
struct SubtreeIsoDataStore initIterativeSubtreeCheck(struct SubtreeIsoDataStore base, struct VertexList* patternEdge, struct GraphPool* gp) {
	// create graph from edge
	struct Graph* h = createGraph(2, gp);
	(h)->vertices[0]->label = patternEdge->startPoint->label;
	(h)->vertices[1]->label = patternEdge->endPoint->label;
	addEdgeBetweenVertices(0, 1, patternEdge->label, h, gp);

	return initIterativeSubtreeCheckForEdge(base, h);

}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x30(%rsp)
movq %rdi, 0x38(%rsp)
leaq 0x60(%rsp), %rax
movq %rax, 0x28(%rsp)
movq %rsi, 0x50(%rsp)
movq %rdx, 0x48(%rsp)
movq 0x48(%rsp), %rsi
movl $0x2, %edi
callq 0xb850
movq %rax, 0x40(%rsp)
movq 0x50(%rsp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rcx
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq %rcx, (%rax)
movq 0x50(%rsp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rcx
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq 0x50(%rsp), %rax
movq (%rax), %rdx
movq 0x40(%rsp), %rcx
movq 0x48(%rsp), %r8
xorl %edi, %edi
movl $0x1, %esi
callq 0xb670
movq 0x28(%rsp), %rcx
movq 0x30(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x20(%rcx), %rdx
movq %rsp, %rax
movq %rdx, 0x20(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0xf3e0
movq 0x38(%rsp), %rax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/iterativeSubtreeIsomorphism.c
// Function: addNoncriticalVertexCharacteristics
void addNoncriticalVertexCharacteristics(struct SubtreeIsoDataStore* data, struct Graph* B, struct Vertex* u, struct Vertex* v) {
	/* the maximum matching computed above covers all but one neighbor of u
	we need to identify those covered neighbors that can be swapped with
	that uncovered neighbor without decreasing the cardinality of the matching
	these are exactly the non-critical vertices.

	a vertex is critical <=> 1.) AND NOT 2.)
	hence
	a vertex is non-critical <=> NOT 1.) OR 2.)
	where
	1.) matched in the matching above
	2.) reachable by augmenting path from the single unmatched vertex.
	This means, all vertices reachable from the single uncovered neighbor of u (including that neighbor are non-critical.
	*/
	struct Vertex* uncoveredNeighbor = NULL;

	// find the single uncovered neighbor of u
	for (int i=0; i<B->number; ++i) {
		if (!isMatched(B->vertices[i])) {
			uncoveredNeighbor = B->vertices[i];
			break;
		}
	}

	// mark all vertices reachable from uncoveredNeighbor by an augmenting path
	markReachable(uncoveredNeighbor, B->number);

	// add non-critical vertices to output
	for (int i=0; i<B->number; ++i) {
		if (B->vertices[i]->visited == 1) {
			// vertex is not critical, add characteristic
			addCharacteristicRaw(data, B->vertices[i]->lowPoint, u->number, v->number);
		}
	}
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x28(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jge 0xf87a
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1ca0
cmpb $0x0, %al
jne 0xf86b
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
jmp 0xf87a
jmp 0xf86d
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0xf829
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rax
movl 0x8(%rax), %esi
callq 0x2e070
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
movq 0x28(%rsp), %rcx
cmpl 0x8(%rcx), %eax
jge 0xf8f8
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rax
cmpl $0x1, 0x1c(%rax)
jne 0xf8e9
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movl 0x20(%rax), %esi
movq 0x20(%rsp), %rax
movl 0x18(%rax), %edx
movq 0x18(%rsp), %rax
movl 0x18(%rax), %ecx
callq 0x230e0
jmp 0xf8eb
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0xf894
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/iterativeSubtreeIsomorphism.c
// Function: noniterativeSubtreeCheck
struct SubtreeIsoDataStore noniterativeSubtreeCheck(struct SubtreeIsoDataStore base, struct Graph* h, struct GraphPool* gp) {
	struct SubtreeIsoDataStore info = {0};
	info.g = base.g;
	info.h = h;
	info.postorder = base.postorder;

	if (info.g->n > 0) {
		info.S = createNewCube(info.g->n, info.h->n);
		noniterativeSubtreeCheck_intern(&info, gp);
		dumpNewCube(info.S, info.g->n);
	} else {
		// if g is empty, then h only matches if it is empty as well.
		// g->n == 0 is a special case that is not handled well by the subtree iso algorithm
		info.foundIso = h->n == 0 ? 1 : 0;
	}

	info.S = NULL;
	return info;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x10(%rsp)
movq %rdi, %rax
movq %rax, (%rsp)
leaq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
xorl %esi, %esi
movl $0x28, %edx
callq 0x10b0
movq 0x8(%rsp), %rax
movq 0x10(%rsp), %rdi
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rdi)
movq 0x20(%rsp), %rcx
movq %rcx, 0x10(%rdi)
movq (%rax), %rax
movq %rax, (%rdi)
movq 0x8(%rdi), %rax
cmpl $0x0, (%rax)
jle 0xf99b
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rcx
movslq (%rcx), %rdi
movq 0x10(%rax), %rax
movslq (%rax), %rsi
callq 0x22ed0
movq 0x10(%rsp), %rdi
movq %rax, 0x18(%rdi)
movq 0x18(%rsp), %rsi
callq 0xf9d0
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x8(%rax), %rax
movl (%rax), %esi
callq 0x22fa0
jmp 0xf9b7
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
movl (%rcx), %esi
xorl %ecx, %ecx
movl $0x1, %edx
cmpl $0x0, %esi
cmovel %edx, %ecx
movl %ecx, 0x20(%rax)
movq (%rsp), %rax
movq 0x10(%rsp), %rcx
movq $0x0, 0x18(%rcx)
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/iterativeSubtreeIsomorphism.c
// Function: isSubtree
char isSubtree(struct Graph* g, struct Graph* h, struct GraphPool* gp) {
	struct SubtreeIsoDataStore info = {0};
	info.g = g;
	info.h = h;

	if (info.g->n > 0) {
		info.postorder = getPostorder(g, 0);
		info.S = createNewCube(info.g->n, info.h->n);
		noniterativeSubtreeCheck_intern(&info, gp);
		dumpNewCube(info.S, info.g->n);
		free(info.postorder);
	} else {
		// if g is empty, then h only matches if it is empty as well.
		// g->n == 0 is a special case that is not handled well by the subtree iso algorithm
		info.foundIso = h->n == 0 ? 1 : 0;
	}

	return info.foundIso;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x10b0
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x10(%rsp), %rax
cmpl $0x0, (%rax)
jle 0xfc69
movq 0x40(%rsp), %rdi
xorl %esi, %esi
callq 0x2df00
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movslq (%rax), %rdi
movq 0x18(%rsp), %rax
movslq (%rax), %rsi
callq 0x22ed0
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rsi
leaq 0x8(%rsp), %rdi
callq 0xf9d0
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rax
movl (%rax), %esi
callq 0x22fa0
movq 0x8(%rsp), %rdi
callq 0x1030
jmp 0xfc81
movq 0x38(%rsp), %rax
movl (%rax), %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovel %ecx, %eax
movl %eax, 0x28(%rsp)
movl 0x28(%rsp), %eax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/iterativeSubtreeIsomorphism.c
// Function: computeRootedSubtreeEmbedding
struct Vertex* computeRootedSubtreeEmbedding(struct Graph* g, struct Vertex* gRoot, struct Graph* h, struct Vertex* hRoot, struct GraphPool* gp) {
	struct SubtreeIsoDataStore info = {0};
	info.g = g;
	info.h = h;
	struct Vertex* rootMapping = NULL;


	if (info.g->n > 0) {
		info.postorder = getPostorder(g, gRoot->number);
		info.S = createNewCube(info.g->n, info.h->n);
		rootMapping = noniterativeRootedSubtreeCheck_intern(&info, hRoot, gp);
		dumpNewCube(info.S, info.g->n);
		free(info.postorder);
	} else {
		// if g is empty, then h only matches if it is empty as well.
		// g->n == 0 is a special case that is not handled well by the subtree iso algorithm
		info.foundIso = h->n == 0 ? 1 : 0;
	}

	return rootMapping;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
leaq 0x8(%rsp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x10b0
movq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
movq $0x0, (%rsp)
movq 0x10(%rsp), %rax
cmpl $0x0, (%rax)
jle 0xfd4a
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rax
movl 0x18(%rax), %esi
callq 0x2df00
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movslq (%rax), %rdi
movq 0x18(%rsp), %rax
movslq (%rax), %rsi
callq 0x22ed0
movq %rax, 0x20(%rsp)
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
leaq 0x8(%rsp), %rdi
callq 0xfd70
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rax
movl (%rax), %esi
callq 0x22fa0
movq 0x8(%rsp), %rdi
callq 0x1030
jmp 0xfd62
movq 0x40(%rsp), %rax
movl (%rax), %edx
xorl %eax, %eax
movl $0x1, %ecx
cmpl $0x0, %edx
cmovel %ecx, %eax
movl %eax, 0x28(%rsp)
movq (%rsp), %rax
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/iterativeSubtreeIsomorphism.c
// Function: noniterativeRootedSubtreeCheck
struct SubtreeIsoDataStore noniterativeRootedSubtreeCheck(struct SubtreeIsoDataStore base, struct Graph* h, struct Vertex** rootEmbedding, struct GraphPool* gp) {
	struct SubtreeIsoDataStore info = {0};
	info.g = base.g;
	info.h = h;
	info.postorder = base.postorder;

	if (info.g->n > 0) {
		info.S = createNewCube(info.g->n, info.h->n);
		*rootEmbedding = noniterativeRootedSubtreeCheck_intern(&info, h->vertices[0], gp);
		dumpNewCube(info.S, info.g->n);
	} else {
		// if g is empty, then h only matches if it is empty as well.
		// g->n == 0 is a special case that is not handled well by the subtree iso algorithm
		info.foundIso = h->n == 0 ? 1 : 0;
	}

	info.S = NULL;
	return info;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
leaq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
xorl %esi, %esi
movl $0x28, %edx
callq 0x10b0
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rdi
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rdi)
movq 0x30(%rsp), %rcx
movq %rcx, 0x10(%rdi)
movq (%rax), %rax
movq %rax, (%rdi)
movq 0x8(%rdi), %rax
cmpl $0x0, (%rax)
jle 0x10068
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rcx
movslq (%rcx), %rdi
movq 0x10(%rax), %rax
movslq (%rax), %rsi
callq 0x22ed0
movq 0x18(%rsp), %rdi
movq %rax, 0x18(%rdi)
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rsi
movq 0x20(%rsp), %rdx
callq 0xfd70
movq %rax, %rdx
movq 0x18(%rsp), %rax
movq 0x28(%rsp), %rcx
movq %rdx, (%rcx)
movq 0x18(%rax), %rdi
movq 0x8(%rax), %rax
movl (%rax), %esi
callq 0x22fa0
jmp 0x10084
movq 0x18(%rsp), %rax
movq 0x30(%rsp), %rcx
movl (%rcx), %esi
xorl %ecx, %ecx
movl $0x1, %edx
cmpl $0x0, %esi
cmovel %edx, %ecx
movl %ecx, 0x20(%rax)
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rcx
movq $0x0, 0x18(%rcx)
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/kruskalsAlgorithm.c
// Function: kruskalMST
struct ShallowGraph* kruskalMST(struct Graph* g, struct VertexList** sortedEdges, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	struct Graph* branching = createGraph(g->n, gp);
	struct ShallowGraph* spanningTree = getShallowGraph(sgp);
	int i;

	for (i=0; i<g->m; ++i) {
		if (isCycleFree(branching, sortedEdges[i], sgp->listPool)) {
			appendEdge(spanningTree, shallowCopyEdge(sortedEdges[i], sgp->listPool));
		}
	}

	dumpGraph(gp, branching);
	return spanningTree;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq 0x40(%rsp), %rax
movl (%rax), %edi
movq 0x30(%rsp), %rsi
callq 0xb850
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x1fe70
movq %rax, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq 0x40(%rsp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x1015a
movq 0x20(%rsp), %rdi
movq 0x38(%rsp), %rax
movslq 0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rdx
callq 0x10180
cmpb $0x0, %al
je 0x1014b
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rax
movslq 0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0xa310
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0xbf70
jmp 0x1014d
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x100e5
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x1fb30
movq 0x18(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/kruskalsAlgorithm.c
// Function: isCycleFree
static char isCycleFree(struct Graph* branching, struct VertexList* e, struct ListPool* lp) {
	// translate vertices to vertices in branching
	struct Vertex* v = branching->vertices[e->startPoint->number];
	struct Vertex* w = branching->vertices[e->endPoint->number];
	// find roots of components
	struct Vertex* rv = getRoot(v);
	struct Vertex* rw = getRoot(w);

	if (rv == rw) {
		return 0;
	} else {
		struct VertexList* f = getVertexList(lp);
		if (rv->d < rw->d) {
			f->startPoint = rv;
			f->endPoint = rw;
			addEdge(rv, f);
			if (rv->d == rw->d) {
				++rw->d;
			}
		} else {
			f->startPoint = rw;
			f->endPoint = rv;
			addEdge(rw, f);
			if (rv->d == rw->d) {
				++rv->d;
			}
		}
		return 1;
	}
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x30(%rsp), %rcx
movq 0x10(%rcx), %rcx
movslq 0x18(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x20(%rsp)
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x30(%rsp), %rcx
movq 0x18(%rcx), %rcx
movslq 0x18(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x102d0
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x102d0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x8(%rsp), %rax
jne 0x10205
movb $0x0, 0x47(%rsp)
jmp 0x102be
movq 0x28(%rsp), %rdi
callq 0x1f310
movq %rax, (%rsp)
movq 0x10(%rsp), %rax
movl 0x28(%rax), %eax
movq 0x8(%rsp), %rcx
cmpl 0x28(%rcx), %eax
jge 0x1026f
movq 0x10(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
callq 0xa660
movq 0x10(%rsp), %rax
movl 0x28(%rax), %eax
movq 0x8(%rsp), %rcx
cmpl 0x28(%rcx), %eax
jne 0x1026d
movq 0x8(%rsp), %rax
movl 0x28(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x28(%rax)
jmp 0x102b9
movq 0x8(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
callq 0xa660
movq 0x10(%rsp), %rax
movl 0x28(%rax), %eax
movq 0x8(%rsp), %rcx
cmpl 0x28(%rcx), %eax
jne 0x102b7
movq 0x10(%rsp), %rax
movl 0x28(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x28(%rax)
jmp 0x102b9
movb $0x1, 0x47(%rsp)
movb 0x47(%rsp), %al
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/kruskalsAlgorithm.c
// Function: getRoot
static struct Vertex* getRoot(struct Vertex* v) {
	struct Vertex* r = v;
	while (r->neighborhood != NULL) {
		r = r->neighborhood->endPoint; 
	}
	return r;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x10(%rsp)
movq -0x10(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x102ff
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rsp)
jmp 0x102df
movq -0x10(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/listComponents.c
// Function: computeCriticality
int* computeCriticality(struct ShallowGraph* biconnectedComponents, int n) {

	/* store for each vertex if the current bic.comp was already counted */
	int* occurrences = malloc(n * sizeof(int));
	/* store the cycle degrees of each vertex in g */
	int* cycleDegrees = malloc(n * sizeof(int));

	int v;
	struct ShallowGraph* comp;
	int compNumber = 0;

	for (v=0; v<n; ++v) {
		occurrences[v] = -1;
		cycleDegrees[v] = 0;
	}


	for (comp = biconnectedComponents; comp!=NULL; comp=comp->next) {
		struct VertexList* e;
		for (e=comp->edges; e!=NULL; e=e->next) {
			if (occurrences[e->startPoint->number] < compNumber) {
				occurrences[e->startPoint->number] = compNumber;
				++cycleDegrees[e->startPoint->number];
			}
			if (occurrences[e->endPoint->number] < compNumber) {
				occurrences[e->endPoint->number] = compNumber;
				++cycleDegrees[e->endPoint->number];
			}
		}
		++compNumber;				
	}
	free(occurrences);
	return cycleDegrees;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movslq 0x3c(%rsp), %rdi
shlq $0x2, %rdi
callq 0x1170
movq %rax, 0x30(%rsp)
movslq 0x3c(%rsp), %rdi
shlq $0x2, %rdi
callq 0x1170
movq %rax, 0x28(%rsp)
movl $0x0, 0x14(%rsp)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
cmpl 0x3c(%rsp), %eax
jge 0x1038c
movq 0x30(%rsp), %rax
movslq 0x24(%rsp), %rcx
movl $0xffffffff, (%rax,%rcx,4) # imm = 0xFFFFFFFF
movq 0x28(%rsp), %rax
movslq 0x24(%rsp), %rcx
movl $0x0, (%rax,%rcx,4)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x10353
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x1048c
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x1046e
movq 0x30(%rsp), %rax
movq 0x8(%rsp), %rcx
movq 0x10(%rcx), %rcx
movslq 0x18(%rcx), %rcx
movl (%rax,%rcx,4), %eax
cmpl 0x14(%rsp), %eax
jge 0x1040a
movl 0x14(%rsp), %edx
movq 0x30(%rsp), %rax
movq 0x8(%rsp), %rcx
movq 0x10(%rcx), %rcx
movslq 0x18(%rcx), %rcx
movl %edx, (%rax,%rcx,4)
movq 0x28(%rsp), %rax
movq 0x8(%rsp), %rcx
movq 0x10(%rcx), %rcx
movslq 0x18(%rcx), %rcx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
movq 0x30(%rsp), %rax
movq 0x8(%rsp), %rcx
movq 0x18(%rcx), %rcx
movslq 0x18(%rcx), %rcx
movl (%rax,%rcx,4), %eax
cmpl 0x14(%rsp), %eax
jge 0x10459
movl 0x14(%rsp), %edx
movq 0x30(%rsp), %rax
movq 0x8(%rsp), %rcx
movq 0x18(%rcx), %rcx
movslq 0x18(%rcx), %rcx
movl %edx, (%rax,%rcx,4)
movq 0x28(%rsp), %rax
movq 0x8(%rsp), %rcx
movq 0x18(%rcx), %rcx
movslq 0x18(%rcx), %rcx
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
movl %edx, (%rax,%rcx,4)
jmp 0x1045b
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x103af
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
jmp 0x10396
movq 0x30(%rsp), %rdi
callq 0x1030
movq 0x28(%rsp), %rax
addq $0x48, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/listComponents.c
// Function: getMaxBlockDegree
int getMaxBlockDegree(struct Graph* g, struct ShallowGraphPool* sgp) {
	int maxDegree = -1;
	struct ShallowGraph* biconnectedComponents = listBiconnectedComponents(g, sgp);
	int* cycleDegrees = computeBlockDegrees(biconnectedComponents, g->n);

	int v;
	for (v=0; v<g->n; ++v) {
		if (maxDegree < cycleDegrees[v]) {
			maxDegree = cycleDegrees[v];
		}
	}

	free(cycleDegrees);
	dumpShallowGraphCycle(sgp, biconnectedComponents);
	return maxDegree;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x10700
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq 0x30(%rsp), %rax
movl (%rax), %esi
callq 0x104a0
movq %rax, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x30(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x106d8
movl 0x24(%rsp), %eax
movq 0x10(%rsp), %rcx
movslq 0xc(%rsp), %rdx
cmpl (%rcx,%rdx,4), %eax
jge 0x106c9
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0x24(%rsp)
jmp 0x106cb
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x10698
movq 0x10(%rsp), %rdi
callq 0x1030
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x20000
movl 0x24(%rsp), %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/listComponents.c
// Function: listBiconnectedComponents
struct ShallowGraph* listBiconnectedComponents(struct Graph* g, struct ShallowGraphPool *gp) {
	int i;

	/* __tarjanFBC needs a static (artificial) head of stack */
	struct VertexList *headOfStack = getVertexList(gp->listPool);

	/* this is where the magic happens. For all vertices: if the vertex is not visited yet,
	 * start find biconnected components for its connected component. This yields a list of
	 * all biconnected components in the graph. */
	struct ShallowGraph *allComponents = NULL;

	/* init ->visited to zero */
	for (i=0; i<g->n; ++i) {
		g->vertices[i]->visited = 0;
	}

	for (i=0; i<g->n; ++i) {
		if (g->vertices[i]->visited == 0) {
			struct ShallowGraph* currentComponents = __tarjanFBC(g->vertices[i], g->vertices[i], 0, headOfStack, gp->listPool, gp);
			allComponents = addComponent(allComponents, currentComponents);
		}
	}


	/* __tarjanFBC returns a cycle of ShallowGraphs. Convert it to a list */
	if (allComponents) {
		allComponents->prev->next = NULL;
		allComponents->prev = NULL;
	} else {
		/* this case should not occur */
		fprintf(stderr, "Error: No cycle of shallow graphs after __tarjanFBC\n");
	}

	/* garbage collection */
	dumpVertexList(gp->listPool, headOfStack);

	/*return results */
	return allComponents;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x1f310
movq %rax, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
movq 0x30(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x10765
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x24(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movl $0x0, 0x1c(%rax)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x10732
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
movq 0x30(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x107ff
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x24(%rsp), %rcx
movq (%rax,%rcx,8), %rax
cmpl $0x0, 0x1c(%rax)
jne 0x107ed
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x24(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x24(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
movq 0x18(%rsp), %rcx
movq 0x28(%rsp), %rax
movq 0x10(%rax), %r8
movq 0x28(%rsp), %r9
xorl %edx, %edx
callq 0x11340
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xbd60
movq %rax, 0x10(%rsp)
jmp 0x107ef
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x1076d
cmpq $0x0, 0x10(%rsp)
je 0x10827
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movq $0x0, 0x18(%rax)
movq 0x10(%rsp), %rax
movq $0x0, 0x20(%rax)
jmp 0x1083f
movq 0x2d7ca(%rip), %rax     # 0x3dff8
movq (%rax), %rdi
leaq 0x24c1a(%rip), %rsi     # 0x35452
movb $0x0, %al
callq 0x1140
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0x1f410
movq 0x10(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/listComponents.c
// Function: getMinBlockDegree
int getMinBlockDegree(struct Graph* g, struct ShallowGraphPool* sgp) {
	int minDegree = INT_MAX;
	struct ShallowGraph* biconnectedComponents = listBiconnectedComponents(g, sgp);
	int* cycleDegrees = computeBlockDegrees(biconnectedComponents, g->n);

	int v;
	for (v=0; v<g->n; ++v) {
		if (minDegree > cycleDegrees[v]) {
			minDegree = cycleDegrees[v];
		}
	}

	free(cycleDegrees);
	dumpShallowGraphCycle(sgp, biconnectedComponents);
	return minDegree;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl $0x7fffffff, 0x24(%rsp) # imm = 0x7FFFFFFF
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x10700
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq 0x30(%rsp), %rax
movl (%rax), %esi
callq 0x104a0
movq %rax, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x30(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x108e8
movl 0x24(%rsp), %eax
movq 0x10(%rsp), %rcx
movslq 0xc(%rsp), %rdx
cmpl (%rcx,%rdx,4), %eax
jle 0x108d9
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0x24(%rsp)
jmp 0x108db
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x108a8
movq 0x10(%rsp), %rdi
callq 0x1030
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x20000
movl 0x24(%rsp), %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/listComponents.c
// Function: getNumberOfBiconnectedComponents
int getNumberOfBiconnectedComponents(struct Graph* g, struct ShallowGraphPool* sgp) {
	struct ShallowGraph* biconnectedComponents = listBiconnectedComponents(g, sgp);
	int compNumber = 0;
	for (struct ShallowGraph* comp = biconnectedComponents; comp!=NULL; comp=comp->next) {
			++compNumber;
	}
	/* cleanup */
	dumpShallowGraphCycle(sgp, biconnectedComponents);
	return compNumber;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x10700
movq %rax, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x10963
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
movq (%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, (%rsp)
jmp 0x10943
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x20000
movl 0xc(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/listComponents.c
// Function: getNumberOfBlocks
int getNumberOfBlocks(struct Graph* g, struct ShallowGraphPool* sgp) {
	if (g->m == 0) {
		return 0;
	}
	struct ShallowGraph* biconnectedComponents = listBiconnectedComponents(g, sgp);
	struct ShallowGraph* comp;
	int compNumber = 0;
	for (comp = biconnectedComponents; comp!=NULL; comp=comp->next) {
		if (comp->m > 1) {
			++compNumber;
		}			
	}
	/* cleanup */
	dumpShallowGraphCycle(sgp, biconnectedComponents);
	return compNumber;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x109a3
movl $0x0, 0x34(%rsp)
jmp 0x10a10
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x10700
movq %rax, 0x18(%rsp)
movl $0x0, 0xc(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x109f9
movq 0x10(%rsp), %rax
cmpl $0x1, 0x10(%rax)
jle 0x109e7
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x109e9
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x109c9
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x20000
movl 0xc(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/listComponents.c
// Function: getMaxNumberOfBlocksPerComponent
int getMaxNumberOfBlocksPerComponent(struct Graph* g, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	struct Graph* components = listConnectedComponents(g, gp);
	int maxNumberOfBlocks = 0;
	for (struct Graph* comp=components; comp!=NULL; comp=comp->next) {
		int numberOfBlocks = getNumberOfBlocks(comp, sgp);
		maxNumberOfBlocks = numberOfBlocks > maxNumberOfBlocks ? numberOfBlocks : maxNumberOfBlocks;
	}
	return maxNumberOfBlocks;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x10ab0
movq %rax, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x10aa5
movq 0x8(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x10980
movl %eax, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0x14(%rsp), %eax
jle 0x10a87
movl 0x4(%rsp), %eax
movl %eax, (%rsp)
jmp 0x10a8e
movl 0x14(%rsp), %eax
movl %eax, (%rsp)
movl (%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x10a59
movl 0x14(%rsp), %eax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/listComponents.c
// Function: listConnectedComponents
struct Graph* listConnectedComponents(struct Graph* g, struct GraphPool* gp) {
	struct Graph* components = NULL;
	int v;
	int componentNumber = 0;

	struct Graph* copy = getGraph(gp);
	setVertexNumber(copy, g->n);

	for (v=0; v<g->n; ++v) {
		g->vertices[v]->visited = -1;
	}
	for (v=0; v<g->n; ++v) {
		if (g->vertices[v]->visited == -1) {
			int m = -1;
			int w;
			struct Graph* currentComponent;

			m = markAndStoreConnectedComponent(g->vertices[v], copy, componentNumber);
			currentComponent = cloneInducedGraph(copy, gp);
			currentComponent->m = m / 2;
			currentComponent->next = components;
			components = currentComponent;
			
			for (w=0; w<copy->n; ++w) {
				copy->vertices[w] = NULL;
			}

			++componentNumber;
		}
	}
	dumpGraph(gp, copy);
	return components;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq $0x0, 0x20(%rsp)
movl $0x0, 0x18(%rsp)
movq 0x28(%rsp), %rdi
callq 0x1fa40
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0x30(%rsp), %rax
movl (%rax), %esi
callq 0xaa00
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movq 0x30(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x10b2a
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x1c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movl $0xffffffff, 0x1c(%rax) # imm = 0xFFFFFFFF
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x10af7
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movq 0x30(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x10c1e
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x1c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
cmpl $-0x1, 0x1c(%rax)
jne 0x10c0c
movl $0xffffffff, 0xc(%rsp)  # imm = 0xFFFFFFFF
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x1c(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x10(%rsp), %rsi
movl 0x18(%rsp), %edx
callq 0x11220
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0xaee0
movq %rax, (%rsp)
movl 0xc(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq (%rsp), %rax
movl %ecx, 0x4(%rax)
movq 0x20(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x18(%rax)
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x10c01
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x8(%rsp), %rcx
movq $0x0, (%rax,%rcx,8)
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x10bd1
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x10c0e
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x10b32
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x1fb30
movq 0x20(%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/listComponents.c
// Function: getNumberOfBridges
int getNumberOfBridges(struct Graph* g, struct ShallowGraphPool* sgp) {
	struct ShallowGraph* biconnectedComponents = listBiconnectedComponents(g, sgp);
	struct ShallowGraph* comp;
	int bridgeNumber = 0;
	for (comp = biconnectedComponents; comp!=NULL; comp=comp->next) {
		if (comp->m == 1) {
			++bridgeNumber;
		}			
	}
	/* cleanup */
	dumpShallowGraphCycle(sgp, biconnectedComponents);
	return bridgeNumber;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x10700
movq %rax, 0x10(%rsp)
movl $0x0, 0x4(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x10ca4
movq 0x8(%rsp), %rax
cmpl $0x1, 0x10(%rax)
jne 0x10c92
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x10c94
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x10c74
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x20000
movl 0x4(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/listComponents.c
// Function: getNumberOfBridgeTrees
int getNumberOfBridgeTrees(struct Graph* g, struct ShallowGraphPool* sgp, struct GraphPool* gp) {
	struct ShallowGraph* h = listBiconnectedComponents(g, sgp);
	struct Graph* forest = partitionIntoForestAndCycles(h, g, gp, sgp);
	int nConnectedComponents = getAndMarkConnectedComponents(forest);
	dumpGraphList(gp, forest);
	return nConnectedComponents;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x10700
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x28(%rsp), %rcx
callq 0x10d30
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x11160
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x1fc60
movl 0xc(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/listComponents.c
// Function: getAndMarkConnectedComponents
int getAndMarkConnectedComponents(struct Graph* g) {
	int componentNumber = 0;
	int v;
	for (v=0; v<g->n; ++v) {
		g->vertices[v]->visited = -1;
	}
	for (v=0; v<g->n; ++v) {
		if (g->vertices[v]->visited == -1) {
			markConnectedComponent(g->vertices[v], componentNumber);
			++componentNumber;
		}
	}
	return componentNumber;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x111ac
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movl $0xffffffff, 0x1c(%rax) # imm = 0xFFFFFFFF
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x11179
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x1120e
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rax
cmpl $-0x1, 0x1c(%rax)
jne 0x111ff
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movl 0xc(%rsp), %esi
callq 0x112d0
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x11201
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x111b4
movl 0xc(%rsp), %eax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/listComponents.c
// Function: markAndStoreConnectedComponent
int markAndStoreConnectedComponent(struct Vertex *v, struct Graph* copy, int component) {
	struct VertexList *index;
	int m = 0;

	/* mark vertex as visited */
	v->visited = component;
	// store pointer to vertex in copy graph
	copy->vertices[v->number] = v;

	/*recursive call for all neighbors that are not visited so far */
	for (index = v->neighborhood; index; index = index->next) {
		++m;
		if (index->endPoint->visited != component) {
			m += markAndStoreConnectedComponent(index->endPoint, copy, component);
		}
	}
	return m;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movl $0x0, 0x4(%rsp)
movl 0x14(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x1c(%rax)
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x20(%rsp), %rcx
movslq 0x18(%rcx), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x112c5
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movl 0x1c(%rax), %eax
cmpl 0x14(%rsp), %eax
je 0x112b3
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x18(%rsp), %rsi
movl 0x14(%rsp), %edx
callq 0x11220
addl 0x4(%rsp), %eax
movl %eax, 0x4(%rsp)
jmp 0x112b5
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x1126f
movl 0x4(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/listComponents.c
// Function: markConnectedComponent
void markConnectedComponent(struct Vertex *v, int component) {
	struct VertexList *index;

	/* mark vertex as visited */
	v->visited = component;

	/*recursive call for all neighbors that are not visited so far */
	for (index = v->neighborhood; index; index = index->next) {
		if (index->endPoint->visited != component) {
			markConnectedComponent(index->endPoint, component);
		}
	}
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl 0xc(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x1c(%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x1132f
movq (%rsp), %rax
movq 0x18(%rax), %rax
movl 0x1c(%rax), %eax
cmpl 0xc(%rsp), %eax
je 0x1131f
movq (%rsp), %rax
movq 0x18(%rax), %rdi
movl 0xc(%rsp), %esi
callq 0x112d0
jmp 0x11321
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
jmp 0x112f6
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/listCycles.c
// Function: getNumberOfSimpleCycles
int getNumberOfSimpleCycles(struct Graph* g, struct ShallowGraphPool* sgp, struct GraphPool* gp) {
	struct Graph* tmp;
	struct Graph* idx;
	int numCycles = 0;

	/* find biconnected Components */
	struct ShallowGraph* h = listBiconnectedComponents(g, sgp);
	struct Graph* forest = partitionIntoForestAndCycles(h, g, gp, sgp);
	/* TODO refactor */
	struct Graph* biconnectedComponents = forest->next;

	/* list all cycles */
	struct ShallowGraph* simpleCycles = NULL;


	for (idx=biconnectedComponents; idx; idx=idx->next) {
		simpleCycles = addComponent(simpleCycles, listCycles(idx, sgp));
	}

	/* if cycles were found, compute canonical strings */
	if (simpleCycles) {
		struct ShallowGraph* cycle = NULL;

		/* transform cycle of shallow graphs to a list */
		simpleCycles->prev->next = NULL;
		simpleCycles->prev = NULL;

		for (cycle=simpleCycles; cycle!=NULL; cycle=cycle->next) {
			++numCycles;
		}

		dumpShallowGraphCycle(sgp, simpleCycles);
	} 

	/* garbage collection */
	for (idx=biconnectedComponents; idx; idx=tmp) {
		tmp = idx->next;
		dumpGraph(gp, idx);
	}
	dumpGraph(gp, forest);

	/* each cycle is found twice */
	return numCycles / 2;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movl $0x0, 0x3c(%rsp)
movq 0x60(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0x10700
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
movq 0x60(%rsp), %rsi
movq 0x50(%rsp), %rdx
movq 0x58(%rsp), %rcx
callq 0x10d30
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x40(%rsp)
cmpq $0x0, 0x40(%rsp)
je 0x11681
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rdi
movq 0x58(%rsp), %rsi
callq 0x11750
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0xbd60
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x40(%rsp)
jmp 0x1163e
cmpq $0x0, 0x18(%rsp)
je 0x116ec
movq $0x0, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq 0x20(%rax), %rax
movq $0x0, 0x18(%rax)
movq 0x18(%rsp), %rax
movq $0x0, 0x20(%rax)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x116dd
movl 0x3c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x3c(%rsp)
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x116ba
movq 0x58(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x20000
movq 0x20(%rsp), %rax
movq %rax, 0x40(%rsp)
cmpq $0x0, 0x40(%rsp)
je 0x11727
movq 0x40(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x48(%rsp)
movq 0x50(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x1fb30
movq 0x48(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x116f6
movq 0x50(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x1fb30
movl 0x3c(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
addq $0x68, %rsp
retq
nopw (%rax,%rax)