LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
callq 0xb40f
testq %rax, %rax
je 0xb406
movq %rax, %r14
xorl %ebp, %ebp
movq %r14, %rdi
movq %rbx, %rsi
callq 0xb38e
cmpl %ebp, %eax
cmovgl %eax, %ebp
movq 0x18(%r14), %r14
testq %r14, %r14
jne 0xb3eb
jmp 0xb408
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
movq %rsi, (%rsp)
movq %rsi, %rdi
callq 0x146a9
movq %rax, %r14
movl (%r15), %esi
movq %rax, %rdi
callq 0x7e6c
movslq (%r15), %rcx
testq %rcx, %rcx
jle 0xb4d3
movq 0x10(%r15), %rax
xorl %edx, %edx
movq (%rax,%rdx,8), %rsi
movl $0xffffffff, 0x1c(%rsi) # imm = 0xFFFFFFFF
incq %rdx
cmpq %rdx, %rcx
jne 0xb449
xorl %r12d, %r12d
testl %ecx, %ecx
jle 0xb4d3
xorl %ebx, %ebx
xorl %r13d, %r13d
movq 0x10(%r15), %rax
movq (%rax,%rbx,8), %rdi
cmpl $-0x1, 0x1c(%rdi)
jne 0xb4c6
movq %r14, %rsi
movl %r12d, %edx
callq 0xb82c
movl %eax, %ebp
movq %r14, %rdi
movq (%rsp), %rsi
callq 0x80df
movl %ebp, %ecx
shrl $0x1f, %ecx
addl %ebp, %ecx
sarl %ecx
movl %ecx, 0x4(%rax)
movq %r13, 0x18(%rax)
movslq (%r14), %rcx
testq %rcx, %rcx
jle 0xb4bd
xorl %edx, %edx
movq 0x10(%r14), %rsi
movq $0x0, (%rsi,%rdx,8)
incq %rdx
cmpq %rdx, %rcx
jne 0xb4a9
incl %r12d
movl (%r15), %ecx
movq %rax, %r13
incq %rbx
movslq %ecx, %rax
cmpq %rax, %rbx
jl 0xb468
jmp 0xb4d6
xorl %r13d, %r13d
movq (%rsp), %rdi
movq %r14, %rsi
callq 0x14700
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_O3/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:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
callq 0xb23b
xorl %ebp, %ebp
testq %rax, %rax
je 0xb51d
movq %rax, %rcx
xorl %edx, %edx
cmpl $0x1, 0x10(%rcx)
sete %dl
addl %edx, %ebp
movq 0x18(%rcx), %rcx
testq %rcx, %rcx
jne 0xb509
movq %rbx, %rdi
movq %rax, %rsi
callq 0x14a56
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0xb23b
movq %rax, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq 0xb57c
movq %rax, %r14
movq %rax, %rdi
callq 0xb7cc
movl %eax, %ebp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x147c9
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r14
pushq %rbx
movslq (%rdi), %rax
testq %rax, %rax
jle 0xb823
movq %rdi, %rbx
movq 0x10(%rdi), %rcx
xorl %edx, %edx
movq (%rcx,%rdx,8), %rsi
movl $0xffffffff, 0x1c(%rsi) # imm = 0xFFFFFFFF
incq %rdx
cmpq %rdx, %rax
jne 0xb7e1
testl %eax, %eax
jle 0xb823
xorl %r14d, %r14d
xorl %ebp, %ebp
movq 0x10(%rbx), %rcx
movq (%rcx,%r14,8), %rdi
cmpl $-0x1, 0x1c(%rdi)
jne 0xb816
movl %ebp, %esi
callq 0xb883
incl %ebp
movl (%rbx), %eax
incq %r14
movslq %eax, %rcx
cmpq %rcx, %r14
jl 0xb7fd
jmp 0xb825
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, 0x1c(%rdi)
movq 0x10(%rsi), %rax
movslq 0x18(%rdi), %rcx
movq %rdi, (%rax,%rcx,8)
movq 0x8(%rdi), %r15
testq %r15, %r15
je 0xb874
movl %edx, %ebx
movq %rsi, %r14
xorl %ebp, %ebp
incl %ebp
movq 0x18(%r15), %rdi
cmpl %ebx, 0x1c(%rdi)
je 0xb869
movq %r14, %rsi
movl %ebx, %edx
callq 0xb82c
addl %eax, %ebp
movq 0x8(%r15), %r15
testq %r15, %r15
jne 0xb852
jmp 0xb876
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, 0x1c(%rdi)
movq 0x8(%rdi), %r14
testq %r14, %r14
je 0xb8ae
movl %esi, %ebx
movq 0x18(%r14), %rdi
cmpl %ebx, 0x1c(%rdi)
je 0xb8a5
movl %ebx, %esi
callq 0xb883
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0xb895
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
callq 0xb23b
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r12, %rcx
callq 0xb57c
movq %rax, %r14
movq 0x18(%rax), %r15
testq %r15, %r15
je 0xbacc
xorl %ebp, %ebp
movq %r15, %r13
movq %r13, %rdi
movq %r12, %rsi
callq 0xbb0d
movq %rbp, %rdi
movq %rax, %rsi
callq 0x883e
movq %rax, %rbp
movq 0x18(%r13), %r13
testq %r13, %r13
jne 0xba77
testq %rbp, %rbp
je 0xbad1
movq 0x20(%rbp), %rax
xorl %r13d, %r13d
movq %r13, 0x18(%rax)
movq %r13, 0x20(%rbp)
movq %rbp, %rax
incl %r13d
movq 0x18(%rax), %rax
testq %rax, %rax
jne 0xbab0
movq %r12, %rdi
movq %rbp, %rsi
callq 0x14a56
shrl %r13d
jmp 0xbad4
xorl %r13d, %r13d
jmp 0xbaf0
xorl %r13d, %r13d
testq %r15, %r15
je 0xbaf0
movq 0x18(%r15), %r12
movq %rbx, %rdi
movq %r15, %rsi
callq 0x14700
movq %r12, %r15
testq %r12, %r12
jne 0xbad9
movq %rbx, %rdi
movq %r14, %rsi
callq 0x14700
movl %r13d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/listCycles.c
// Function: listCycles
struct ShallowGraph* listCycles(struct Graph *g, struct ShallowGraphPool *sgp) {
	int i;
	struct ShallowGraph* result = NULL;


	/* TODO should be: for each cycle start vertex */
	for (i=0; i<g->n; ++i) {
		/* check if this one belongs to some union of cycles */
		/* TODO remove this as we just compute stuff for cycle start vertices */
		if ((g->vertices[i] != NULL) && (g->vertices[i]->neighborhood != NULL)) {


			struct ShallowGraph *currentPath = getShallowGraph(sgp);
			struct ShallowGraph *newCycle;


			g->vertices[i]->visited = 1;

			newCycle = __backtrack(g, g->vertices[i], g->vertices[i], g->vertices[i], i, currentPath, sgp);

			result = addComponent(result, newCycle);

			dumpShallowGraph(sgp, currentPath);
			g->vertices[i]->visited = 0;
		}
	}

	return result;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x10, %rsp
movl (%rdi), %eax
testl %eax, %eax
jle 0xbbae
movq %rsi, %rbx
movq %rdi, %r14
movq 0x10(%rdi), %rcx
xorl %r15d, %r15d
xorl %r12d, %r12d
movq (%rcx,%r15,8), %rdx
testq %rdx, %rdx
je 0xbba1
cmpq $0x0, 0x8(%rdx)
je 0xbba1
movq %rbx, %rdi
callq 0x1498d
movq %rax, %r13
movq 0x10(%r14), %rax
movq (%rax,%r15,8), %rcx
movl $0x1, 0x1c(%rcx)
movq %rbx, (%rsp)
movq %r14, %rdi
movq %rcx, %rsi
movq %rcx, %rdx
movl %r15d, %r8d
movq %r13, %r9
callq 0xbe29
movq %r12, %rdi
movq %rax, %rsi
callq 0x883e
movq %rax, %r12
movq %rbx, %rdi
movq %r13, %rsi
callq 0x149f4
movq 0x10(%r14), %rcx
movq (%rcx,%r15,8), %rax
movl $0x0, 0x1c(%rax)
movl (%r14), %eax
incq %r15
movslq %eax, %rdx
cmpq %rdx, %r15
jl 0xbb34
jmp 0xbbb1
xorl %r12d, %r12d
movq %r12, %rax
addq $0x10, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/listCycles.c
// Function: getNumberOfNonIsoCycles
int getNumberOfNonIsoCycles(struct Graph* g, struct ShallowGraphPool* sgp, struct GraphPool* gp) {
	struct Graph* tmp;
	struct Graph* idx;
	int numCycles;

	/* 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;
	struct ShallowGraph* cyclePatterns = NULL;
	struct Vertex* cyclePatternSearchTree = NULL;

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

	/* if cycles were found, compute canonical strings */
	if (simpleCycles) {
		/* transform cycle of shallow graphs to a list */
		simpleCycles->prev->next = NULL;
		simpleCycles->prev = NULL;

		cyclePatterns = getCyclePatterns(simpleCycles, sgp);
		cyclePatternSearchTree = buildSearchTree(cyclePatterns, gp, sgp);

		numCycles = cyclePatternSearchTree->number;
	} else {
		numCycles = 0;
	}

	/* garbage collection */

	/* dump cycles, if any
	 * TODO may be moved upwards directly after finding simple cycles */
	if (cyclePatternSearchTree) {
			dumpSearchTree(gp, cyclePatternSearchTree);
	}

	/* dump biconnected components list */
	for (idx=biconnectedComponents; idx; idx=tmp) {
		tmp = idx->next;
		dumpGraph(gp, idx);
	}

	dumpGraph(gp, forest);

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
callq 0xb23b
movq %rax, %rdi
movq %r14, %rsi
movq %rbx, %rdx
movq %r12, %rcx
callq 0xb57c
movq %rax, %r14
movq 0x18(%rax), %r15
testq %r15, %r15
je 0xbc65
xorl %r13d, %r13d
movq %r15, %rbp
movq %rbp, %rdi
movq %r12, %rsi
callq 0xbb0d
movq %r13, %rdi
movq %rax, %rsi
callq 0x883e
movq %rax, %r13
movq 0x18(%rbp), %rbp
testq %rbp, %rbp
jne 0xbbfe
testq %r13, %r13
je 0xbc69
movq 0x20(%r13), %rax
xorl %ecx, %ecx
movq %rcx, 0x18(%rax)
movq %rcx, 0x20(%r13)
movq %r13, %rdi
movq %r12, %rsi
callq 0x5de1
movq %rax, %rdi
movq %rbx, %rsi
movq %r12, %rdx
callq 0x1b614
movl 0x18(%rax), %ecx
movl %ecx, %ebp
shrl $0x1f, %ebp
addl %ecx, %ebp
sarl %ebp
movq %rbx, %rdi
movq %rax, %rsi
callq 0x1b546
jmp 0xbc6b
xorl %ebp, %ebp
jmp 0xbc87
xorl %ebp, %ebp
testq %r15, %r15
je 0xbc87
movq 0x18(%r15), %r12
movq %rbx, %rdi
movq %r15, %rsi
callq 0x14700
movq %r12, %r15
testq %r12, %r12
jne 0xbc70
movq %rbx, %rdi
movq %r14, %rsi
callq 0x14700
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/listCycles.c
// Function: _findPathIntern
char __findPathIntern(struct Vertex* v, struct Vertex* parent, struct Vertex* target, int allowance, struct ShallowGraph* path, struct ShallowGraphPool* sgp) {
	struct VertexList *idx;
	char found = 0;


	/* this is an exception for the case where the target is the neighbor of parent
	 * and __backtrack calls findPath(target, parent, target, ...) */
	if (v == target) {
		return 1;
	}

	if (v->visited == 0) {

		v->lowPoint = 1;

		for (idx=v->neighborhood; idx; idx=idx->next) {

			if (idx->endPoint != parent) {
				/* this "removes" vertices that are too small from adjacency lists */
				if  (idx->endPoint->number >= allowance) {

					/* breaking condition: s is reached second argument avoids "cycles" of lenght 4
					 * of the type target-parent-v-parent-target */
					if (idx->endPoint == target){

						pushEdge(path, shallowCopyEdge(idx, sgp->listPool));
						return 1;

					} else {
						/* otherwise check if the endpoint was already visited. if not try recursively */
						if ((idx->endPoint->lowPoint == 0) && (idx->endPoint->visited == 0)) {

							found = __findPathIntern(idx->endPoint, v, target, allowance, path, sgp);

							/* if we have found a path, return this path via path */
							if (found) {
								pushEdge(path, shallowCopyEdge(idx, sgp->listPool));
								break;
							} /* fi found */
						} /* fi not visited */
					} /* esle endPoint = s */
				} /* fi >= allowance */
			} /* fi not parent */
		} /* rof */
	} /* fi */
	return found;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movb $0x1, %bl
cmpq %rdx, %rdi
je 0xbd33
movq %rdi, %r14
cmpl $0x0, 0x1c(%rdi)
jne 0xbd31
movl $0x1, 0x20(%r14)
movq 0x8(%r14), %r15
testq %r15, %r15
je 0xbd31
movl %ecx, %ebp
movq %rdx, %r12
movq %rsi, %r13
movq %r8, 0x10(%rsp)
movq %r9, 0x8(%rsp)
movq 0x18(%r15), %rdi
cmpq %r13, %rdi
je 0xbd28
cmpl %ebp, 0x18(%rdi)
jl 0xbd28
cmpq %r12, %rdi
je 0xbd44
cmpl $0x0, 0x20(%rdi)
jne 0xbd28
cmpl $0x0, 0x1c(%rdi)
jne 0xbd28
movq %r14, %rsi
movq %r12, %rdx
movl %ebp, %ecx
movq 0x10(%rsp), %r8
movq 0x8(%rsp), %r9
callq 0xbca3
movq 0x8(%rsp), %r9
movq 0x10(%rsp), %r8
testb %al, %al
jne 0xbd44
movq 0x8(%r15), %r15
testq %r15, %r15
jne 0xbce4
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x10(%r9), %rsi
movq %r15, %rdi
movq %r8, %r14
callq 0x7bec
movq %r14, %rdi
movq %rax, %rsi
callq 0x848a
jmp 0xbd33
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/listCycles.c
// Function: _cleanUpLowPoint
void __cleanUpLowPoint(struct Vertex*v) {
	struct VertexList* idx;
	v->lowPoint = 0;
	for (idx=v->neighborhood; idx; idx=idx->next) {
		if (idx->endPoint->lowPoint != 0) {
			__cleanUpLowPoint(idx->endPoint);
		}
	}
}

// Assembly:
pushq %rbx
movl $0x0, 0x20(%rdi)
movq 0x8(%rdi), %rbx
testq %rbx, %rbx
je 0xbd86
movq 0x18(%rbx), %rdi
cmpl $0x0, 0x20(%rdi)
je 0xbd80
callq 0xbd60
movq 0x8(%rbx), %rbx
jmp 0xbd6c
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/listCycles.c
// Function: _DFS
char __DFS(struct Vertex* v, struct Vertex* parent, struct Vertex* target, int allowance) {
	struct VertexList* idx;
	char flag = 0;

	if(v->number == target->number)
		return 1;

	/* mark current vertex as visited */
	v->d = 1;

	for (idx=v->neighborhood; idx; idx=idx->next) {
		/* do not consider vertices smaller than allowance and not the edge back to the parent, also only from desired bicomp */
		if ((idx->endPoint->number >= allowance) && (idx->endPoint->number != parent->number)) {
			if (!flag) {
				if (idx->endPoint->number == target->number)
					flag = 1;
				else if (idx->endPoint->d == 0)
					flag = __DFS(idx->endPoint, v, target, allowance);
			}
		}
	}

	return flag;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movl %ecx, %ebx
movl 0x18(%rdi), %ecx
movb $0x1, %al
cmpl 0x18(%rdx), %ecx
je 0xbe1f
movq %rdi, %r12
movl $0x1, 0x28(%rdi)
movq 0x8(%rdi), %r13
testq %r13, %r13
je 0xbe1d
movq %rdx, %r14
movq %rsi, %r15
xorl %eax, %eax
movq 0x18(%r13), %rdi
movl 0x18(%rdi), %ecx
cmpl %ebx, %ecx
jl 0xbe12
cmpl 0x18(%r15), %ecx
sete %dl
testb %al, %al
setne %sil
orb %dl, %sil
jne 0xbe12
movb $0x1, %al
cmpl 0x18(%r14), %ecx
je 0xbe12
cmpl $0x0, 0x28(%rdi)
je 0xbe05
xorl %eax, %eax
jmp 0xbe12
movq %r12, %rsi
movq %r14, %rdx
movl %ebx, %ecx
callq 0xbda6
movq 0x8(%r13), %r13
testq %r13, %r13
jne 0xbdd6
jmp 0xbe1f
xorl %eax, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/listCycles.c
// Function: listCyclesOfLength
struct ShallowGraph* listCyclesOfLength(struct Graph *g, int cycleLength, struct ShallowGraphPool *sgp) {
	struct ShallowGraph* result = listCycles(g, sgp);

	if (result) {

		struct ShallowGraph* last = result->prev;
		for (struct ShallowGraph* c=result; c!=last; ) {
			if (c->m != cycleLength) {
				struct ShallowGraph* dump = c;
				dump->prev->next = dump->next;
				dump->next->prev = dump->prev;
				c = dump->next;
				dumpShallowGraph(sgp, dump);
			} else {
				c = c->next;
			}
		}
		if (last->m != cycleLength) {
			struct ShallowGraph* c = last;
			if (c->prev == last) {
				last = NULL;
			} else {
				c->prev->next = c->next;
				c->next->prev = c->prev;
				last = c->next;
			}
			dumpShallowGraph(sgp, c);
		}
		result = last;
	}

	return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdx, %rsi
callq 0xbb0d
testq %rax, %rax
je 0xc1e3
movq %rax, %rsi
movq 0x20(%rax), %r14
cmpq %r14, %rax
je 0xc1c6
movq 0x18(%rsi), %r15
cmpl %ebp, 0x10(%rsi)
je 0xc1be
movq 0x20(%rsi), %rax
movq %r15, 0x18(%rax)
movq %rax, 0x20(%r15)
movq %rbx, %rdi
callq 0x149f4
movq %r15, %rsi
cmpq %r14, %r15
jne 0xc1a1
cmpl %ebp, 0x10(%r14)
je 0xc1f9
movq 0x20(%r14), %rax
cmpq %r14, %rax
je 0xc1e8
movq 0x18(%r14), %r15
movq %r15, 0x18(%rax)
movq %rax, 0x20(%r15)
jmp 0xc1eb
xorl %r14d, %r14d
jmp 0xc1f9
xorl %r15d, %r15d
movq %rbx, %rdi
movq %r14, %rsi
callq 0x149f4
movq %r15, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/listSpanningTrees.c
// Function: _visit
void __visit(struct Vertex* v, int component, int* components) {
	struct VertexList* e;

	if (components[v->number] != -1) {
		return;
	}

	components[v->number] = component;

	for (e=v->neighborhood; e!=NULL; e=e->next) {
		__visit(e->endPoint, component, components);
	}
}

// Assembly:
movslq 0x18(%rdi), %rax
cmpl $-0x1, (%rdx,%rax,4)
je 0xc213
retq
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %ebp
movl %esi, (%rdx,%rax,4)
movq 0x8(%rdi), %r14
testq %r14, %r14
je 0xc23c
movq 0x18(%r14), %rdi
movl %ebp, %esi
movq %rbx, %rdx
callq 0xc208
movq 0x8(%r14), %r14
jmp 0xc223
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/listSpanningTrees.c
// Function: _selectB
struct ShallowGraph* __selectB(struct Graph* partialTree, struct ShallowGraph* rest, int* components, int n, struct ShallowGraphPool* sgp) {
	struct ShallowGraph* B = getShallowGraph(sgp);
	struct VertexList* e;

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

	/* mark connected components */
	for (int v=0; v<n; ++v) {
		__visit(partialTree->vertices[v], v, components);
	}

	for (e=rest->edges; e!=NULL; e=e->next) {
		int v = e->startPoint->number;
		int w = e->endPoint->number;
		if ((components[v] != -1) && (components[w] != -1) && (components[v] == components[w])) {
			e->flag = 1;
		}
	}

	B->next = getShallowGraph(sgp);
	for (e=rest->edges; e!=NULL; e=rest->edges) {
		if (e->flag == 1) {
			pushEdge(B, popEdge(rest));
		} else {
			pushEdge(B->next, popEdge(rest));
		}
	}
	return B;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %ecx, %ebp
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r13
movq %r8, (%rsp)
movq %r8, %rdi
callq 0x1498d
movq %rax, %r14
testl %ebp, %ebp
jle 0xc29e
movl %ebp, %r15d
leaq (,%r15,4), %rdx
movq %r12, %rdi
movl $0xff, %esi
callq 0x10d0
xorl %ebp, %ebp
movq 0x10(%r13), %rax
movq (%rax,%rbp,8), %rdi
movl %ebp, %esi
movq %r12, %rdx
callq 0xc208
incq %rbp
cmpq %rbp, %r15
jne 0xc284
movq (%rbx), %rax
testq %rax, %rax
je 0xc2d2
movq 0x10(%rax), %rcx
movslq 0x18(%rcx), %rcx
movl (%r12,%rcx,4), %ecx
cmpl $-0x1, %ecx
je 0xc2cc
movq 0x18(%rax), %rdx
movslq 0x18(%rdx), %rdx
cmpl (%r12,%rdx,4), %ecx
jne 0xc2cc
movl $0x1, 0x24(%rax)
movq 0x8(%rax), %rax
jmp 0xc2a1
movq (%rsp), %rdi
callq 0x1498d
movq %rax, 0x18(%r14)
movq (%rbx), %rax
testq %rax, %rax
je 0xc309
cmpl $0x1, 0x24(%rax)
movq %r14, %r15
je 0xc2f4
movq 0x18(%r14), %r15
movq %rbx, %rdi
callq 0x88ee
movq %r15, %rdi
movq %rax, %rsi
callq 0x848a
jmp 0xc2df
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/listSpanningTrees.c
// Function: _getGraphAndNonGraphEdges
struct ShallowGraph* __getGraphAndNonGraphEdges(struct Graph* graph, struct ShallowGraph* list, struct ShallowGraphPool* sgp) {
	struct VertexList* e;
	struct ShallowGraph* graphEdges = getShallowGraph(sgp);
	struct ShallowGraph* nonGraphEdges = getShallowGraph(sgp);

	/* mark edges that are in graph */
	for (e=list->edges; e!=NULL; e=e->next) {
		e->flag = isNeighbor(graph, e->startPoint->number, e->endPoint->number);
	}

	/* consume list putting differently flagged edges in different lists */
	for (e=list->edges; e!=NULL; e=list->edges) {
		if (e->flag == 1) {
			pushEdge(graphEdges, popEdge(list));
		} else {
			pushEdge(nonGraphEdges, popEdge(list));
		}
	}
	dumpShallowGraph(sgp, list);

	graphEdges->next = nonGraphEdges;
	nonGraphEdges->prev = graphEdges;
	return graphEdges;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r13
movq %rdx, %rdi
callq 0x1498d
movq %rax, %r15
movq %r14, %rdi
callq 0x1498d
movq %rax, %r12
movq (%rbx), %rbp
testq %rbp, %rbp
je 0xc39a
movq 0x10(%rbp), %rax
movq 0x18(%rbp), %rcx
movl 0x18(%rax), %esi
movl 0x18(%rcx), %edx
movq %r13, %rdi
callq 0x83c5
movsbl %al, %eax
movl %eax, 0x24(%rbp)
movq 0x8(%rbp), %rbp
testq %rbp, %rbp
jne 0xc34d
jmp 0xc392
movl 0x24(%rax), %ebp
movq %rbx, %rdi
callq 0x88ee
movq %r15, %rdi
cmpl $0x1, %ebp
je 0xc38a
movq %r12, %rdi
movq %rax, %rsi
callq 0x848a
movq (%rbx), %rax
testq %rax, %rax
jne 0xc374
movq %r14, %rdi
movq %rbx, %rsi
callq 0x149f4
movq %r12, 0x18(%r15)
movq %r15, 0x20(%r12)
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_O3/pwelke[P]GraphMiningTools/listSpanningTrees.c
// Function: _getNonTreeBridges
struct ShallowGraph* __getNonTreeBridges(struct Graph* graph, struct Graph* partialTree, struct ShallowGraphPool* sgp) {
	struct ShallowGraph* tmp = getShallowGraph(sgp);
	struct ShallowGraph* biconnectedComponents = listBiconnectedComponents(graph, sgp);
	struct ShallowGraph* idx;
	struct ShallowGraph* nonTreeBridges;

	/* find bridges in graph */
	for (idx=biconnectedComponents; idx; idx=idx->next) {
		if (idx->m == 1) {
			pushEdge(tmp, popEdge(idx));
		} 
	}
	dumpShallowGraphCycle(sgp, biconnectedComponents);

	tmp = __getGraphAndNonGraphEdges(partialTree, tmp, sgp);
	nonTreeBridges = tmp->next;
	tmp->next = NULL;
	dumpShallowGraph(sgp, tmp);

	return nonTreeBridges;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r12
movq %rdx, %rdi
callq 0x1498d
movq %rax, %r15
movq %r12, %rdi
movq %rbx, %rsi
callq 0xb23b
movq %rax, %r12
testq %rax, %rax
je 0xc416
movq %r12, %r13
cmpl $0x1, 0x10(%r13)
jne 0xc40d
movq %r13, %rdi
callq 0x88ee
movq %r15, %rdi
movq %rax, %rsi
callq 0x848a
movq 0x18(%r13), %r13
testq %r13, %r13
jne 0xc3f3
movq %rbx, %rdi
movq %r12, %rsi
callq 0x14a56
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0xc31b
movq 0x18(%rax), %r14
movq $0x0, 0x18(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x149f4
movq %r14, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/listSpanningTrees.c
// Function: listSpanningTrees
struct ShallowGraph* listSpanningTrees(struct Graph* original, struct ShallowGraphPool* sgp, struct GraphPool* gp) {
	
	struct Graph* graph = cloneGraph(original, gp);
	struct Graph* partialTree = emptyGraph(original, gp);
	struct ShallowGraph* result = NULL;
	int* components = malloc(sizeof(int) * original->n);
	struct ShallowGraph* idx;

	/* add all bridges to partialTree */
	struct ShallowGraph* biconnectedComponents = listBiconnectedComponents(original, sgp);
	for (idx=biconnectedComponents; idx; idx=idx->next) {
		struct VertexList* e = idx->edges;
		if (idx->m == 1) {
			addEdgeBetweenVertices(e->startPoint->number, e->endPoint->number, e->label, partialTree, gp);
		}
	}
	dumpShallowGraphCycle(sgp, biconnectedComponents);
	
	/* do the backtrack, baby */
	result = __rec(0, graph, partialTree, components, graph->n, sgp, gp);
	result->prev->next = NULL;
	result->prev = NULL;

	/* edges in result point to vertices in partialTree this has to be changed */
	rebaseShallowGraphs(result, original);

	/* garbage collection */
	free(components);
	dumpGraph(gp, graph);
	dumpGraph(gp, partialTree);

	return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %rbx
movq %rsi, %r13
movq %rdi, %r12
movq %rdx, %rsi
callq 0x7fc9
movq %rax, 0x10(%rsp)
movq %r12, %rdi
movq %rbx, %rsi
callq 0x8576
movq %rax, %r15
movslq (%r12), %rdi
shlq $0x2, %rdi
callq 0x1190
movq %rax, 0x8(%rsp)
movq %r12, %rdi
movq %r13, %rsi
callq 0xb23b
movq %rax, %r14
testq %rax, %rax
je 0xc6c8
movq %r14, %rbp
cmpl $0x1, 0x10(%rbp)
jne 0xc6bf
movq (%rbp), %rax
movq (%rax), %rdx
movq 0x10(%rax), %rcx
movl 0x18(%rcx), %edi
movq 0x18(%rax), %rax
movl 0x18(%rax), %esi
movq %r15, %rcx
movq %rbx, %r8
callq 0x84a3
movq 0x18(%rbp), %rbp
testq %rbp, %rbp
jne 0xc699
movq %r13, %rdi
movq %r14, %rsi
callq 0x14a56
movq 0x10(%rsp), %rbp
movl (%rbp), %r8d
movq %rbx, (%rsp)
xorl %edi, %edi
movq %rbp, %rsi
movq %r15, %rdx
movq 0x8(%rsp), %r14
movq %r14, %rcx
movq %r13, %r9
callq 0xc453
movq %rax, %r13
movq 0x20(%rax), %rax
xorl %ecx, %ecx
movq %rcx, 0x18(%rax)
movq %rcx, 0x20(%r13)
movq %r13, %rdi
movq %r12, %rsi
callq 0x87b6
movq %r14, %rdi
callq 0x1030
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x14700
movq %rbx, %rdi
movq %r15, %rsi
callq 0x14700
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_O3/pwelke[P]GraphMiningTools/listSpanningTrees.c
// Function: countSpanningTrees
long int countSpanningTrees(struct Graph* original, long int maxBound, struct ShallowGraphPool* sgp, struct GraphPool* gp) {

	struct Graph* graph = cloneGraph(original, gp);
	struct Graph* partialTree = emptyGraph(original, gp);
	long int result;
	int* components = malloc(sizeof(int) * original->n);
	struct ShallowGraph* idx;

	/* add all bridges to partialTree */
	struct ShallowGraph* biconnectedComponents = listBiconnectedComponents(original, sgp);
	for (idx=biconnectedComponents; idx; idx=idx->next) {
		struct VertexList* e = idx->edges;
		if (idx->m == 1) {
			addEdgeBetweenVertices(e->startPoint->number, e->endPoint->number, e->label, partialTree, gp);
		}
	}
	dumpShallowGraphCycle(sgp, biconnectedComponents);
	
	/* do the backtrack, baby */
	result = __recCount(maxBound, graph, partialTree, components, graph->n, sgp, gp);

	/* garbage collection */
	free(components);
	dumpGraph(gp, graph);
	dumpGraph(gp, partialTree);

	return result;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, 0x10(%rsp)
movq %rdi, %r13
movq %rcx, %rsi
callq 0x7fc9
movq %rax, %r14
movq %r13, %rdi
movq %rbx, %rsi
callq 0x8576
movq %rax, %r15
movslq (%r13), %rdi
shlq $0x2, %rdi
callq 0x1190
movq %rax, 0x8(%rsp)
movq %r13, %rdi
movq %r12, %rsi
callq 0xb23b
movq %rax, %rbp
testq %rax, %rax
je 0xcd6c
movq %rbp, %r13
cmpl $0x1, 0x10(%r13)
jne 0xcd63
movq (%r13), %rax
movq (%rax), %rdx
movq 0x10(%rax), %rcx
movl 0x18(%rcx), %edi
movq 0x18(%rax), %rax
movl 0x18(%rax), %esi
movq %r15, %rcx
movq %rbx, %r8
callq 0x84a3
movq 0x18(%r13), %r13
testq %r13, %r13
jne 0xcd3c
movq %r12, %rdi
movq %rbp, %rsi
callq 0x14a56
movl (%r14), %r8d
movq %rbx, (%rsp)
movq 0x10(%rsp), %rdi
movq %r14, %rsi
movq %r15, %rdx
movq 0x8(%rsp), %r13
movq %r13, %rcx
movq %r12, %r9
callq 0xca8c
movq %rax, %r12
movq %r13, %rdi
callq 0x1030
movq %rbx, %rdi
movq %r14, %rsi
callq 0x14700
movq %rbx, %rdi
movq %r15, %rsi
callq 0x14700
movq %r12, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/listSpanningTrees.c
// Function: countNonisomorphicSpanningTrees
int countNonisomorphicSpanningTrees(struct Graph* g, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	int i = 0;

	struct Vertex* searchTree = getVertex(gp->vertexPool);

	// list the spanning trees, canonicalize them and add them in a search tree (to avoid duplicates, i.e. isomorphic spanning trees
	struct ShallowGraph* sample = listSpanningTrees(g, sgp, gp);
	for (struct ShallowGraph* tree=sample; tree!=NULL; tree=tree->next) {
		if (tree->m != 0) {
			struct Graph* tmp = shallowGraphToGraph(tree, gp);
			struct ShallowGraph* cString = canonicalStringOfTree(tmp, sgp);
			addToSearchTree(searchTree, cString, gp, sgp);
			/* garbage collection */
			dumpGraph(gp, tmp);
		}
	}

	// this is the number of isomorphism classes
	i = searchTree->d;

	dumpShallowGraphCycle(sgp, sample);
	dumpSearchTree(gp, searchTree);

	return i;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %r12
movq 0x10(%rsi), %rdi
callq 0x1447e
movq %rax, %r15
movq %r12, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xc63f
movq %rax, %r12
testq %rax, %rax
je 0xce4a
movq %r12, %r13
cmpl $0x0, 0x10(%r13)
je 0xce41
movq %r13, %rdi
movq %rbx, %rsi
callq 0x8250
movq %rax, %rbp
movq %rax, %rdi
movq %r14, %rsi
callq 0x7938
movq %r15, %rdi
movq %rax, %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq 0x1ae1e
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x14700
movq 0x18(%r13), %r13
testq %r13, %r13
jne 0xce05
movl 0x28(%r15), %ebp
movq %r14, %rdi
movq %r12, %rsi
callq 0x14a56
movq %rbx, %rdi
movq %r15, %rsi
callq 0x1b546
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/loading.c
// Function: initCache
void initCache() {
	HEAD_SIZE = malloc(sizeof(size_t));
	*HEAD_SIZE = 2048;
	HEAD_PTR = malloc(sizeof(char*));
	*HEAD_PTR = malloc(*HEAD_SIZE * sizeof(char));

	VERTEX_SIZE = malloc(sizeof(size_t));
	*VERTEX_SIZE = 2048;
	VERTEX_PTR = malloc(sizeof(char*));
	*VERTEX_PTR = malloc(*VERTEX_SIZE * sizeof(char));

	EDGE_SIZE = malloc(sizeof(size_t));
	*EDGE_SIZE = 2048;
	EDGE_PTR = malloc(sizeof(char*));
	*EDGE_PTR = malloc(*EDGE_SIZE * sizeof(char));
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl $0x8, %edi
callq 0x1190
movq %rax, 0x200cb(%rip)     # 0x2d198
movl $0x800, %r14d           # imm = 0x800
movq %r14, (%rax)
movl $0x8, %edi
callq 0x1190
movq %rax, %rbx
movq %rax, 0x200a6(%rip)     # 0x2d190
movl $0x800, %edi            # imm = 0x800
callq 0x1190
movq %rax, (%rbx)
movl $0x8, %edi
callq 0x1190
movq %rax, 0x200a0(%rip)     # 0x2d1a8
movq %r14, (%rax)
movl $0x8, %edi
callq 0x1190
movq %rax, %rbx
movq %rax, 0x20081(%rip)     # 0x2d1a0
movl $0x800, %edi            # imm = 0x800
callq 0x1190
movq %rax, (%rbx)
movl $0x8, %edi
callq 0x1190
movq %rax, 0x2007b(%rip)     # 0x2d1b8
movq %r14, (%rax)
movl $0x8, %edi
callq 0x1190
movq %rax, %rbx
movq %rax, 0x2005c(%rip)     # 0x2d1b0
movl $0x800, %edi            # imm = 0x800
callq 0x1190
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/loading.c
// Function: createFileIterator
void createFileIterator(char* filename, struct GraphPool* p) {

	if ((FI_DATABASE = fopen(filename, "r"))) {
		FI_GP = p;
		initCache();
	} else {
		printf("File %s not found\n", filename);
	}

}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x12f83(%rip), %rsi     # 0x200fd
callq 0x11d0
movq %rax, 0x1fffa(%rip)     # 0x2d180
testq %rax, %rax
je 0xd19e
movq %r14, 0x1fff6(%rip)     # 0x2d188
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0xd0b8
leaq 0x1344f(%rip), %rdi     # 0x205f4
movq %rbx, %rsi
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x10b0
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/loading.c
// Function: destroyFileIterator
void destroyFileIterator() {
	fclose(FI_DATABASE);
	
	free(HEAD_SIZE);
	free(*HEAD_PTR);
	free(HEAD_PTR);
	HEAD_PTR = NULL;
	HEAD_SIZE = NULL;

	free(VERTEX_SIZE);
	free(*VERTEX_PTR);
	free(VERTEX_PTR);
	VERTEX_PTR = NULL;
	VERTEX_SIZE = NULL;

	free(EDGE_SIZE);
	free(*EDGE_PTR);
	free(EDGE_PTR);
	EDGE_PTR = NULL;
	EDGE_SIZE = NULL;
}

// Assembly:
pushq %rbx
movq 0x1ffa5(%rip), %rdi     # 0x2d180
callq 0x1090
movq 0x1ffb1(%rip), %rdi     # 0x2d198
callq 0x1030
movq 0x1ff9d(%rip), %rax     # 0x2d190
movq (%rax), %rdi
callq 0x1030
movq 0x1ff8e(%rip), %rdi     # 0x2d190
callq 0x1030
xorl %ebx, %ebx
movq %rbx, 0x1ff80(%rip)     # 0x2d190
movq %rbx, 0x1ff81(%rip)     # 0x2d198
movq 0x1ff8a(%rip), %rdi     # 0x2d1a8
callq 0x1030
movq 0x1ff76(%rip), %rax     # 0x2d1a0
movq (%rax), %rdi
callq 0x1030
movq 0x1ff67(%rip), %rdi     # 0x2d1a0
callq 0x1030
movq %rbx, 0x1ff5b(%rip)     # 0x2d1a0
movq %rbx, 0x1ff5c(%rip)     # 0x2d1a8
movq 0x1ff65(%rip), %rdi     # 0x2d1b8
callq 0x1030
movq 0x1ff51(%rip), %rax     # 0x2d1b0
movq (%rax), %rdi
callq 0x1030
movq 0x1ff42(%rip), %rdi     # 0x2d1b0
callq 0x1030
movq %rbx, 0x1ff36(%rip)     # 0x2d1b0
movq %rbx, 0x1ff37(%rip)     # 0x2d1b8
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/loading.c
// Function: parseEdgeNew
static inline int parseEdgeNew(const char** currentPosition, int* v, int* w, char** label) {
	*v = fastAtoi(currentPosition);
	*w = fastAtoi(currentPosition);
	grabLabel(currentPosition, label);
	return (*v != -1) + (*w != -1) + (*label != NULL);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbp
movq %rdx, %r12
movq %rsi, %rbx
movq %rdi, %r15
movq (%rdi), %r13
callq 0x1260
movq (%rax), %rcx
leaq -0x1(%r13), %rdx
movsbq 0x1(%rdx), %rdi
incq %rdx
testb $0x20, 0x1(%rcx,%rdi,2)
jne 0xd854
addl $-0x30, %edi
xorl %esi, %esi
movq %rdx, %r8
cmpl $0x9, %edi
ja 0xd88b
xorl %esi, %esi
movq %rdx, %r8
leal (%rsi,%rsi,4), %esi
leal (%rdi,%rsi,2), %esi
movsbl 0x1(%r8), %edi
incq %r8
addl $-0x30, %edi
cmpl $0xa, %edi
jb 0xd875
cmpq %r8, %rdx
je 0xd89b
movq %r8, (%r15)
movq (%rax), %rcx
movq %r8, %r13
jmp 0xd8a0
movl $0xffffffff, %esi       # imm = 0xFFFFFFFF
movl %esi, (%rbx)
decq %r13
movsbq 0x1(%r13), %rdx
incq %r13
testb $0x20, 0x1(%rcx,%rdx,2)
jne 0xd8a5
addl $-0x30, %edx
xorl %r14d, %r14d
movq %r13, %rcx
cmpl $0x9, %edx
ja 0xd8df
xorl %r14d, %r14d
movq %r13, %rcx
leal (%r14,%r14,4), %esi
leal (%rdx,%rsi,2), %r14d
movsbl 0x1(%rcx), %edx
incq %rcx
addl $-0x30, %edx
cmpl $0xa, %edx
jb 0xd8c8
cmpq %rcx, %r13
movq %rbx, 0x10(%rsp)
je 0xd8ee
movq %rcx, (%r15)
jmp 0xd8f4
movl $0xffffffff, %r14d      # imm = 0xFFFFFFFF
movl %r14d, (%r12)
movq $0x0, (%rbp)
movq (%r15), %rcx
movq (%rax), %rax
movsbq (%rcx), %rdx
movzwl (%rax,%rdx,2), %edx
xorl %ebx, %ebx
btl $0xd, %edx
movq %rbp, 0x8(%rsp)
jb 0xd920
xorl %r12d, %r12d
jmp 0xd939
xorl %r12d, %r12d
movsbq 0x1(%rcx,%r12), %rdx
incq %r12
movzwl (%rax,%rdx,2), %edx
btl $0xd, %edx
jb 0xd923
addq %r12, %rcx
btl $0xd, %edx
jb 0xd99d
xorl %r13d, %r13d
movsbq 0x1(%rcx,%r13), %rdx
incq %r13
testb $0x20, 0x1(%rax,%rdx,2)
je 0xd942
xorl %ebx, %ebx
testq %r13, %r13
je 0xd99d
leaq 0x1(%r13), %rdi
callq 0x1190
movq %rax, %rbp
movq 0x8(%rsp), %rax
movq %rbp, (%rax)
testq %rbp, %rbp
je 0xd99d
addq (%r15), %r12
movq %rbp, %rdi
movq %r12, %rsi
movq %r13, %rdx
callq 0x1170
movb $0x0, (%rbp,%r13)
addq %r13, %r12
movq %r12, (%r15)
xorl %ebx, %ebx
movq 0x8(%rsp), %rax
cmpq $0x0, (%rax)
setne %bl
xorl %ecx, %ecx
movq 0x10(%rsp), %rax
cmpl $-0x1, (%rax)
setne %cl
xorl %eax, %eax
cmpl $-0x1, %r14d
setne %al
addl %ebx, %eax
addl %ecx, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/loading.c
// Function: intLabel
char* intLabel(const unsigned int label) {
	int bufferSize;
	char* representation;
	
	if (label>1) {
		bufferSize = (int)ceil(log10(label)) + 2;
	} else {
		bufferSize = 3;
	}

	representation = malloc(bufferSize * sizeof(char));
	if (representation) {
		sprintf(representation, "%i", label);
	}
	return representation;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
movl $0x3, %edi
cmpl $0x2, %ebx
jb 0xdd24
movl %ebx, %eax
cvtsi2sd %rax, %xmm0
callq 0x1150
callq 0x1240
cvttsd2si %xmm0, %eax
addl $0x2, %eax
movslq %eax, %rdi
callq 0x1190
movq %rax, %r14
testq %rax, %rax
je 0xdd44
leaq 0x13872(%rip), %rsi     # 0x215aa
movq %r14, %rdi
movl %ebx, %edx
xorl %eax, %eax
callq 0x1210
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/localEasiness.c
// Function: getMaxLocalEasiness
int getMaxLocalEasiness(struct Graph* g, long int maxBound, struct GraphPool* gp, struct ShallowGraphPool* sgp) {

	long int max = -1;
	struct ShallowGraph* biconnectedComponents = listBiconnectedComponents(g, sgp);
	long int* easiness = computeLocalEasinessExactly(biconnectedComponents, g->n, maxBound, gp, sgp);
	dumpShallowGraphCycle(sgp, biconnectedComponents);
	for (int v=0; v<g->n; ++v) {
		// problem occurred. counting did not work
		if (easiness[v] == 0) {
			return -1;
		}
		if (easiness[v] > max) {
			max = easiness[v];
		}
	}
	free(easiness);
	return (max > (long int)INT_MAX) ? -1 : (int)max;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
movq %rcx, %rsi
callq 0xb23b
movq %rax, %r13
movl (%r12), %esi
movq %rax, %rdi
movq %r15, %rdx
movq %rbx, %rcx
movq %r14, %r8
callq 0xe450
movq %rax, %rbx
movq %r14, %rdi
movq %r13, %rsi
callq 0x14a56
movslq (%r12), %rax
testq %rax, %rax
jle 0xe6f6
movq $-0x1, %r14
xorl %ecx, %ecx
movq (%rbx,%rcx,8), %rdx
testq %rdx, %rdx
je 0xe6fe
cmpq %r14, %rdx
cmovgq %rdx, %r14
incq %rcx
cmpq %rcx, %rax
jne 0xe6c4
movq %rbx, %rdi
callq 0x1030
cmpq $0x7fffffff, %r14       # imm = 0x7FFFFFFF
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmovlel %r14d, %eax
jmp 0xe703
movq %rbx, %rdi
callq 0x1030
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/localEasiness.c
// Function: getMinLocalEasiness
int getMinLocalEasiness(struct Graph* g, long int maxBound, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	long int min = -1;
	struct ShallowGraph* biconnectedComponents = listBiconnectedComponents(g, sgp);
	long int* easiness = computeLocalEasinessExactly(biconnectedComponents, g->n, maxBound, gp, sgp);
	dumpShallowGraphCycle(sgp, biconnectedComponents);
	for (int v=0; v<g->n; ++v) {
		// error occurred. skip it.
		if (easiness[v] == 0) {
			continue;
		}
		if ((easiness[v] < min) || (min == -1)) {
			min = easiness[v];
		}
	}
	free(easiness);
	return (min > (long int)INT_MAX) ? -1 : (int)min;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rcx, %r14
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r12
movq %rcx, %rsi
callq 0xb23b
movq %rax, %r13
movl (%r12), %esi
movq %rax, %rdi
movq %r15, %rdx
movq %rbx, %rcx
movq %r14, %r8
callq 0xe450
movq %rax, %rbx
movq %r14, %rdi
movq %r13, %rsi
callq 0x14a56
movslq (%r12), %rax
testq %rax, %rax
jle 0xe7a1
movq $-0x1, %r14
xorl %ecx, %ecx
movq %r14, %rdx
movq (%rbx,%rcx,8), %rsi
cmpq %r14, %rsi
cmovlq %rsi, %r14
cmpq $-0x1, %rdx
cmoveq %rsi, %r14
testq %rsi, %rsi
cmoveq %rdx, %r14
incq %rcx
cmpq %rcx, %rax
jne 0xe762
movq %rbx, %rdi
callq 0x1030
cmpq $0x7fffffff, %r14       # imm = 0x7FFFFFFF
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
cmovlel %r14d, %eax
jmp 0xe7ae
movq %rbx, %rdi
callq 0x1030
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/localEasySubtreeIsomorphism.c
// Function: spanningTreeConverter
struct Graph* spanningTreeConverter(struct ShallowGraph* localTrees, struct Graph* component, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	struct Graph* resultingTrees = NULL;
	for (struct ShallowGraph* tree=popShallowGraph(&localTrees); tree!=NULL; tree=popShallowGraph(&localTrees)) {

		struct Graph* result = emptyGraph(component, gp);
		result->m = tree->m;
		// copy root information
		for (int v=0; v<result->n; ++v) {
			result->vertices[v]->d = component->vertices[v]->d;
		}

		// transfer edges, add to vertices
		rebaseShallowGraphs(tree, result);
		for (struct VertexList* e=popEdge(tree); e!=NULL; e=popEdge(tree)) {
			addEdge(e->startPoint, e);
			addEdge(e->endPoint, inverseEdge(e, gp->listPool));
		}
		dumpShallowGraph(sgp, tree);
		result->next = resultingTrees;
		resultingTrees = result;
	}
	return resultingTrees;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, 0x10(%rsp)
movq %rsi, (%rsp)
testq %rdi, %rdi
je 0xec09
movq %rdx, %r14
movq %rdi, %r12
movq 0x18(%rdi), %r15
movq $0x0, 0x18(%rdi)
movq $0x0, 0x8(%rsp)
movq (%rsp), %rdi
movq %r14, %rsi
callq 0x8576
movq %rax, %r13
movl 0x10(%r12), %eax
movl %eax, 0x4(%r13)
movslq (%r13), %rax
testq %rax, %rax
jle 0xeb8e
movq (%rsp), %rcx
movq 0x10(%rcx), %rcx
movq 0x10(%r13), %rdx
xorl %esi, %esi
movq (%rcx,%rsi,8), %rdi
movl 0x28(%rdi), %edi
movq (%rdx,%rsi,8), %r8
movl %edi, 0x28(%r8)
incq %rsi
cmpq %rsi, %rax
jne 0xeb77
movq %r12, %rdi
movq %r13, %rsi
callq 0x87b6
movq %r12, %rdi
callq 0x88ee
movq %rax, %rbp
testq %rax, %rax
je 0xebd2
movq 0x10(%rbp), %rdi
movq %rbp, %rsi
callq 0x7cfe
movq 0x18(%rbp), %rbx
movq 0x18(%r14), %rsi
movq %rbp, %rdi
callq 0x7c08
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7cfe
jmp 0xeb99
movq 0x10(%rsp), %rdi
movq %r12, %rsi
callq 0x149f4
movq 0x8(%rsp), %rax
movq %rax, 0x18(%r13)
testq %r15, %r15
je 0xec0c
movq 0x18(%r15), %rax
movq $0x0, 0x18(%r15)
movq %r13, 0x8(%rsp)
movq %r15, %r12
movq %rax, %r15
jmp 0xeb48
xorl %r13d, %r13d
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_O3/pwelke[P]GraphMiningTools/localEasySubtreeIsomorphism.c
// Function: compareShallowGraphs
int compareShallowGraphs(struct ShallowGraph* g, struct ShallowGraph* h, int (*compar)(const struct VertexList*, const struct VertexList*)) {
//	if (g->m == 0) {
//		if (h->m == 0) {
//			return 0;
//		} else {
//			return -1;
//		}
//	} else {
//		if (h->m == 0) {
//			return 1;
//		} else {
			return compareVertexListsGeneric(g->edges, h->edges, compar);
//		}
//	}

}

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
testq %rdi, %rdi
je 0xee1f
movq %rdi, %r14
movq 0x18(%rdi), %rax
testq %rax, %rax
je 0xee27
movq %rsi, %r12
xorl %r15d, %r15d
movq %r14, %r13
xorl %ebp, %ebp
movq %rax, %r14
movq %r13, %rdi
movq %rax, %rsi
callq *%r12
testl %eax, %eax
movq %rbp, %rax
cmoveq %r15, %rax
cmoveq %r13, %r15
cmovneq %r13, %rbp
movq %rax, 0x18(%r13)
movq 0x18(%r14), %rax
movq %r14, %r13
testq %rax, %rax
jne 0xedf0
jmp 0xee2c
xorl %r15d, %r15d
xorl %r14d, %r14d
jmp 0xee30
xorl %ebp, %ebp
xorl %r15d, %r15d
movq %rbp, 0x18(%r14)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x14a56
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq