LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/cs_Tree.c
// Function: canonicalStringOfLevelTree
struct ShallowGraph* canonicalStringOfLevelTree(struct ShallowGraph* vertexList, int maxDepth, struct ShallowGraphPool* sgp) {

	struct VertexList* idx;
	struct ShallowGraph* canonicalString = NULL;

	/* compute the canonical string of the unique tree rooted at vertex i and save it at the correct position of the
	canonicalStrings array */
	for (idx=vertexList->edges; idx && (idx->endPoint->visited <= maxDepth); idx=idx->next) {

		/* compute the canonical string */
		struct ShallowGraph *cs = canonicalStringOfRootedLevelTree(idx->endPoint, NULL, maxDepth, sgp);

		/* keep the string if its the first one, computed for this component or lexicograhically smaller
			than the saved string */
		if (canonicalString) {
			if (compareCanonicalStrings(canonicalString, cs) > 0) {
				dumpShallowGraph(sgp, canonicalString);
				canonicalString = cs;
			} else {
				dumpShallowGraph(sgp, cs);
			}
		} else {
			canonicalString = cs;
		}

	}

	return canonicalString;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq (%rdi), %r12
testq %r12, %r12
je 0x77ce
movq %rdx, %rbx
movl %esi, %ebp
xorl %r14d, %r14d
movq 0x18(%r12), %rdi
cmpl %ebp, 0x1c(%rdi)
jg 0x77d3
xorl %esi, %esi
movl %ebp, %edx
movq %rbx, %rcx
callq 0x7555
movq %rax, %r15
testq %r14, %r14
je 0x77bf
movq %r14, %rdi
movq %r15, %rsi
callq 0x5b1f
movq %rbx, %rdi
testl %eax, %eax
jle 0x77b4
movq %r14, %rsi
callq 0x149f4
jmp 0x77bf
movq %r15, %rsi
callq 0x149f4
movq %r14, %r15
movq 0x8(%r12), %r12
movq %r15, %r14
testq %r12, %r12
jne 0x777a
jmp 0x77d6
xorl %r15d, %r15d
jmp 0x77d6
movq %r14, %r15
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/cs_Tree.c
// Function: canonicalStringOfTree
struct ShallowGraph* canonicalStringOfTree(struct Graph* tree, struct ShallowGraphPool* sgp) {
	struct ShallowGraph* cString;
	int* center = treeCenter(tree);

	cString = canonicalStringOfRootedTree(tree->vertices[center[1]], tree->vertices[center[1]], sgp);
	
	if (center[0] == 3) {
		struct ShallowGraph* cString2 = canonicalStringOfRootedTree(tree->vertices[center[2]], tree->vertices[center[2]], sgp);
		if (compareCanonicalStrings(cString, cString2) < 0) {
			dumpShallowGraph(sgp, cString2);
		} else {
			dumpShallowGraph(sgp, cString);
			cString = cString2;
		}
	}
	free(center);
	return cString;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r12
callq 0x1d304
movq %rax, %rbx
movq 0x10(%r12), %rax
movslq 0x4(%rbx), %rcx
movq (%rax,%rcx,8), %rdi
movq %rdi, %rsi
movq %r14, %rdx
callq 0x736c
movq %rax, %r15
cmpl $0x3, (%rbx)
jne 0x79a9
movq 0x10(%r12), %rax
movslq 0x8(%rbx), %rcx
movq (%rax,%rcx,8), %rdi
movq %rdi, %rsi
movq %r14, %rdx
callq 0x736c
movq %rax, %r12
movq %r15, %rdi
movq %rax, %rsi
callq 0x5b1f
testl %eax, %eax
movq %r15, %rsi
cmovsq %r12, %rsi
cmovnsq %r12, %r15
movq %r14, %rdi
callq 0x149f4
movq %rbx, %rdi
callq 0x1030
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/cs_Tree.c
// Function: _canonicalString2GraphRec
int __canonicalString2GraphRec(struct Graph* g, int current, int parent, struct ShallowGraph* suffix, struct VertexList* initEdge, struct VertexList* termEdge, struct GraphPool* gp) {

	/* for all children of parent */
	while (suffix->edges != NULL) {
		char* edgeLabel;

		if (strcmp(suffix->edges->label, termEdge->label) == 0) {
			suffix->edges = suffix->edges->next;
			return current;
		}
		
		/* first comes edge label */
		suffix->edges = suffix->edges->next;
		edgeLabel = suffix->edges->label;

		/* now comes the vertex label */
		suffix->edges = suffix->edges->next;
		g->vertices[current]->label = suffix->edges->label;

		addEdgeBetweenVertices(parent, current, edgeLabel, g, gp);

		/* recursive call */
		suffix->edges = suffix->edges->next;
		current = __canonicalString2GraphRec(g, current + 1, current, suffix, initEdge, termEdge, gp);
	}

	/* return position of next free vertex in g */
	return current;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, 0x10(%rsp)
movl %edx, 0xc(%rsp)
movl %esi, %r15d
movq (%rcx), %rbp
testq %rbp, %rbp
je 0x7a6e
movq %r9, %rbx
movq %rcx, %r14
movq %rdi, %r12
movq 0x50(%rsp), %r13
movq (%rbp), %rdi
movq (%rbx), %rsi
callq 0x1140
movq 0x8(%rbp), %rcx
testl %eax, %eax
je 0x7a6b
movq (%rcx), %rdx
movq 0x8(%rcx), %rax
movq %rax, (%r14)
movq (%rax), %rax
movq 0x10(%r12), %rcx
movslq %r15d, %r15
movq (%rcx,%r15,8), %rcx
movq %rax, (%rcx)
movl 0xc(%rsp), %edi
movl %r15d, %esi
movq %r12, %rcx
movq %r13, %r8
callq 0x84a3
movq (%r14), %rax
movq 0x8(%rax), %rax
movq %rax, (%r14)
leal 0x1(%r15), %esi
movq %r13, (%rsp)
movq %r12, %rdi
movl %r15d, %edx
movq %r14, %rcx
movq 0x10(%rsp), %r8
movq %rbx, %r9
callq 0x79c0
movl %eax, %r15d
movq (%r14), %rbp
testq %rbp, %rbp
jne 0x79f4
jmp 0x7a6e
movq %rcx, (%r14)
movl %r15d, %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/cs_Tree.c
// Function: treeCanonicalString2Graph
struct Graph* treeCanonicalString2Graph(struct ShallowGraph* pattern, struct GraphPool* gp) {
	struct VertexList* initEdge = getInitialisatorEdge(gp->listPool);
	struct VertexList* termEdge = getTerminatorEdge(gp->listPool);
	struct VertexList* e;
	int n = 0;
	struct Graph* g;
	struct VertexList* head = pattern->edges;

	/* find number of vertices, create graph */
	for (e=pattern->edges; e!=NULL; e=e->next) {
		if (strcmp(e->label, initEdge->label) == 0) {
			++n;
		}
	}
	g = createGraph(n + 1, gp);

	/* create tree from canonical string recursively */
	g->vertices[0]->label = pattern->edges->label;
	pattern->edges = pattern->edges->next;
	__canonicalString2GraphRec(g, 1, 0, pattern, initEdge, termEdge, gp);
	pattern->edges = head;

	/* cleanup */
	dumpVertexList(gp->listPool, initEdge);
	dumpVertexList(gp->listPool, termEdge);

	return g;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rsi), %rdi
callq 0x709c
movq %rax, %r12
movq 0x18(%rbx), %rdi
callq 0x708a
movq %rax, 0x10(%rsp)
movq (%r14), %r15
testq %r15, %r15
je 0x7ae9
movq %r12, 0x8(%rsp)
movq (%r12), %r13
xorl %ebp, %ebp
movq %r15, %r12
movq (%r12), %rdi
movq %r13, %rsi
callq 0x1140
cmpl $0x1, %eax
adcl $0x0, %ebp
movq 0x8(%r12), %r12
testq %r12, %r12
jne 0x7ac4
incl %ebp
movq 0x8(%rsp), %r12
jmp 0x7aee
movl $0x1, %ebp
movl %ebp, %edi
movq %rbx, %rsi
callq 0x85e3
movq %rax, %r13
movq (%r14), %rax
movq (%rax), %rcx
movq 0x10(%r13), %rdx
movq (%rdx), %rdx
movq %rcx, (%rdx)
movq 0x8(%rax), %rax
movq %rax, (%r14)
movq %rbx, (%rsp)
movq %r13, %rdi
movl $0x1, %esi
xorl %edx, %edx
movq %r14, %rcx
movq %r12, %r8
movq 0x10(%rsp), %rbp
movq %rbp, %r9
callq 0x79c0
movq %r15, (%r14)
movq 0x18(%rbx), %rdi
movq %r12, %rsi
callq 0x14250
movq 0x18(%rbx), %rdi
movq %rbp, %rsi
callq 0x14250
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/cs_Tree.c
// Function: treeCanonicalString2ExistingGraph
void treeCanonicalString2ExistingGraph(struct ShallowGraph* pattern, struct Graph* g, struct GraphPool* gp) {
	struct VertexList* initEdge = getInitialisatorEdge(gp->listPool);
	struct VertexList* termEdge = getTerminatorEdge(gp->listPool);
	struct VertexList* head = pattern->edges;

	/* create tree from canonical string recursively */
	g->vertices[0]->label = pattern->edges->label;
	pattern->edges = pattern->edges->next;
	__canonicalString2GraphRec(g, 1, 0, pattern, initEdge, termEdge, gp);
	pattern->edges = head;

	/* cleanup */
	dumpVertexList(gp->listPool, initEdge);
	dumpVertexList(gp->listPool, termEdge);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x18(%rdx), %rdi
callq 0x709c
movq %rax, %r12
movq 0x18(%rbx), %rdi
callq 0x708a
movq %rax, %r13
movq (%r14), %rbp
movq (%rbp), %rax
movq 0x10(%r15), %rcx
movq (%rcx), %rcx
movq %rax, (%rcx)
movq 0x8(%rbp), %rax
movq %rax, (%r14)
movq %rbx, (%rsp)
movq %r15, %rdi
movl $0x1, %esi
xorl %edx, %edx
movq %r14, %rcx
movq %r12, %r8
movq %r13, %r9
callq 0x79c0
movq %rbp, (%r14)
movq 0x18(%rbx), %rdi
movq %r12, %rsi
callq 0x14250
movq 0x18(%rbx), %rdi
movq %r13, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x14250
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/graph.c
// Function: shallowCopyEdge
struct VertexList* shallowCopyEdge(struct VertexList* e, struct ListPool* p) {
	struct VertexList* f = getVertexList(p);
	f->startPoint = e->startPoint;
	f->endPoint = e->endPoint;
	f->label = e->label;
	/* f does not manage its string but refers to a different lists string, thus it is no stringMaster */
	return f;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x141f1
movups 0x10(%rbx), %xmm0
movups %xmm0, 0x10(%rax)
movq (%rbx), %rcx
movq %rcx, (%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/graph.c
// Function: inverseEdge
struct VertexList* inverseEdge(struct VertexList* e, struct ListPool* p) {
	struct VertexList* f = getVertexList(p);
	f->startPoint = e->endPoint;
	f->endPoint = e->startPoint;
	f->label = e->label;
	/* f does not manage its string but refers to a different lists string, thus it is no stringMaster */
	return f;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x141f1
movq 0x18(%rbx), %rcx
movq %rcx, 0x10(%rax)
movq 0x10(%rbx), %rcx
movq %rcx, 0x18(%rax)
movq (%rbx), %rcx
movq %rcx, (%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/graph.c
// Function: shallowCopyVertex
struct Vertex* shallowCopyVertex(struct Vertex *v, struct VertexPool *p) {
	struct Vertex *new = getVertex(p);
	new->number = v->number;
	new->label = v->label;
	return new;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq %rsi, %rdi
callq 0x1447e
movl 0x18(%rbx), %ecx
movl %ecx, 0x18(%rax)
movq (%rbx), %rcx
movq %rcx, (%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/graph.c
// Function: commonNeighborCount
int commonNeighborCount(struct Vertex* v, struct Vertex* w) {
	struct VertexList* e;
	int count = 0;

	for (e=v->neighborhood; e; e=e->next) {
		e->endPoint->visited = 1;
	}
	for (e=w->neighborhood; e; e=e->next) {
		/* if the endpoint is visited, then there is a triangle
		 * if there are more than two triangles, break */
		if (e->endPoint->visited) {
			++count;
		}
	}
	for (e=v->neighborhood; e; e=e->next) {
		e->endPoint->visited = 0;
	}
	return count;
}

// Assembly:
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
je 0x7c94
movq %rcx, %rax
movq 0x18(%rax), %rdx
movl $0x1, 0x1c(%rdx)
movq 0x8(%rax), %rax
testq %rax, %rax
jne 0x7c80
movq 0x8(%rsi), %rdx
xorl %eax, %eax
testq %rdx, %rdx
je 0x7cc7
movq 0x18(%rdx), %rsi
movq 0x8(%rdx), %rdi
cmpl $0x1, 0x1c(%rsi)
sbbl $-0x1, %eax
movq %rdi, %rdx
testq %rdi, %rdi
jne 0x7c9f
jmp 0x7cc7
movq 0x18(%rcx), %rdx
movl $0x0, 0x1c(%rdx)
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
jne 0x7cb8
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/graph.c
// Function: removeEdge
void removeEdge(struct Vertex* v, struct Vertex* w, struct ListPool* p) {
	struct VertexList* idx, *tmp;

	if (v->neighborhood->endPoint == w) {
		tmp = v->neighborhood;
		v->neighborhood = v->neighborhood->next;
		dumpVertexList(p, tmp);
		return;
	}

	tmp = v->neighborhood;
	for (idx=tmp->next; idx; idx=idx->next, tmp=tmp->next) {
		if (idx->endPoint == w) {
			tmp->next = idx->next;
			dumpVertexList(p, idx);
			return;
		}
	}
}

// Assembly:
movq %rsi, %rax
movq 0x8(%rdi), %rsi
movq 0x8(%rsi), %rcx
cmpq %rax, 0x18(%rsi)
je 0x7d32
testq %rcx, %rcx
je 0x7d31
cmpq %rax, 0x18(%rcx)
je 0x7d38
movq 0x8(%rsi), %rsi
movq 0x8(%rcx), %rcx
jmp 0x7d1c
retq
movq %rcx, 0x8(%rdi)
jmp 0x7d43
movq 0x8(%rcx), %rax
movq %rax, 0x8(%rsi)
movq %rcx, %rsi
movq %rdx, %rdi
jmp 0x14250
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/graph.c
// Function: snatchEdge
struct VertexList* snatchEdge(struct Vertex* v, struct Vertex* w) {
	struct VertexList* idx, *tmp;

	if (v->neighborhood->endPoint == w) {
		tmp = v->neighborhood;
		v->neighborhood = v->neighborhood->next;	
		tmp->next = NULL;
		return tmp;
	}

	tmp = v->neighborhood;
	for (idx=tmp->next; idx; idx=idx->next, tmp=tmp->next) {
		if (idx->endPoint == w) {
			tmp->next = idx->next;
			idx->next = NULL;
			return idx;
		}
	}
	return NULL;
}

// Assembly:
movq 0x8(%rdi), %rax
movq 0x8(%rax), %rcx
cmpq %rsi, 0x18(%rax)
je 0x7d71
testq %rcx, %rcx
je 0x7d6e
cmpq %rsi, 0x18(%rcx)
je 0x7d77
movq 0x8(%rax), %rax
movq 0x8(%rcx), %rcx
jmp 0x7d59
xorl %eax, %eax
retq
movq %rcx, 0x8(%rdi)
jmp 0x7d82
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq %rcx, %rax
movq $0x0, 0x8(%rax)
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/graph.c
// Function: mergeGraphs
struct Graph* mergeGraphs(struct Graph* g, struct GraphPool* gp) {
	int n = 0;
	int m = 0;
	int i = 0;
	struct Graph* current;
	struct Graph* bigGraph = getGraph(gp);

	for (current=g; current!=NULL; current=current->next) {
		n += current->n;
		m += current->m;
	}
	setVertexNumber(bigGraph, n);
	bigGraph->m = m;

	for (current=g; current!=NULL; current=current->next) {
		int v;
		for (v=0; v<current->n; ++v, ++i) {
			bigGraph->vertices[i] = current->vertices[v];
			bigGraph->vertices[i]->number = i;
			current->vertices[v] = NULL;
		}
	}
	for (current=g; current!=NULL; ) {
		struct Graph* tmp = current;
		current = current->next;
		tmp->next = NULL;
		dumpGraph(gp, tmp);
	}
	return bigGraph;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
callq 0x146a9
movq %rax, %rbx
testq %r15, %r15
je 0x7e4f
xorl %esi, %esi
xorl %ebp, %ebp
movq %r15, %rax
addl (%rax), %esi
addl 0x4(%rax), %ebp
movq 0x18(%rax), %rax
testq %rax, %rax
jne 0x7db4
movq %rbx, %rdi
callq 0x7e6c
movl %ebp, 0x4(%rbx)
testq %r15, %r15
je 0x7e60
xorl %eax, %eax
movq %r15, %rcx
movslq (%rcx), %rdx
testq %rdx, %rdx
jle 0x7e25
movslq %eax, %rsi
movl %esi, %edi
xorl %r8d, %r8d
movq 0x10(%rcx), %r9
movq (%r9,%r8,8), %r9
movq 0x10(%rbx), %r10
movq %r9, (%r10,%rsi,8)
movq 0x10(%rbx), %r9
movq (%r9,%rsi,8), %r9
leal (%rdi,%r8), %r10d
movl %r10d, 0x18(%r9)
movq 0x10(%rcx), %r9
movq $0x0, (%r9,%r8,8)
incq %r8
incq %rsi
cmpq %r8, %rdx
jne 0x7deb
addl %r8d, %eax
movq 0x18(%rcx), %rcx
testq %rcx, %rcx
jne 0x7ddb
movq 0x18(%r15), %r12
movq $0x0, 0x18(%r15)
movq %r14, %rdi
movq %r15, %rsi
callq 0x14700
movq %r12, %r15
testq %r12, %r12
jne 0x7e2e
jmp 0x7e60
movq %rbx, %rdi
xorl %esi, %esi
callq 0x7e6c
movl $0x0, 0x4(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/graph.c
// Function: setVertexNumber
struct Vertex** setVertexNumber(struct Graph* g, int n) {
	int i;
	
	if (n<0) {
		printf("Error allocating memory for array of negative size %i\n", n);
		return NULL;
	}
	
	g->n = n;
	g->vertices = malloc(n * sizeof(struct Vertex*));

	for (i=0; i<n; ++i) {
		g->vertices[i] = NULL;
	}

	return g->vertices;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
testl %esi, %esi
js 0x7eb2
movq %rdi, %rbx
movl %ebp, (%rdi)
movl %ebp, %r15d
leaq (,%r15,8), %rdi
callq 0x1190
movq %rax, 0x10(%rbx)
testl %ebp, %ebp
je 0x7ec7
xorl %eax, %eax
movq 0x10(%rbx), %rcx
movq $0x0, (%rcx,%rax,8)
incq %rax
cmpq %rax, %r15
jne 0x7e98
movq 0x10(%rbx), %r14
jmp 0x7eca
leaq 0x182ea(%rip), %rdi     # 0x201a3
xorl %r14d, %r14d
movl %ebp, %esi
xorl %eax, %eax
callq 0x10b0
jmp 0x7eca
movq %rax, %r14
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/graph.c
// Function: deleteEdge
struct VertexList* deleteEdge(struct Graph* g, int v, int w) {
	struct VertexList* e = g->vertices[v]->neighborhood;
	struct VertexList* f = e->next;

	if (e->endPoint->number == w) {
		g->vertices[v]->neighborhood = e->next;
		e->next = NULL;
		return e;
	}

	for ( ; f!=NULL; e=f, f=f->next) {
		if (f->endPoint->number == w) {
			e->next = f->next;
			f->next = NULL;
			return f;
		}
	}
	/* returns NULL, if there is no edge between v and w */
	return NULL;
}

// Assembly:
movq 0x10(%rdi), %rax
movslq %esi, %rcx
movq (%rax,%rcx,8), %rsi
movq 0x8(%rsi), %rax
movq 0x8(%rax), %rcx
movq 0x18(%rax), %rdi
cmpl %edx, 0x18(%rdi)
jne 0x7efa
movq %rcx, 0x8(%rsi)
jmp 0x7f30
testq %rcx, %rcx
je 0x7f39
movq 0x18(%rcx), %rsi
cmpl %edx, 0x18(%rsi)
jne 0x7f0d
movq %rcx, %rsi
jmp 0x7f25
movq 0x8(%rcx), %rsi
testq %rsi, %rsi
je 0x7f39
movq 0x18(%rsi), %rdi
movq %rcx, %rax
movq %rsi, %rcx
cmpl %edx, 0x18(%rdi)
jne 0x7f0d
movq 0x8(%rsi), %rcx
movq %rcx, 0x8(%rax)
movq %rsi, %rax
movq $0x0, 0x8(%rax)
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/graph.c
// Function: deleteEdgeBetweenVertices
void deleteEdgeBetweenVertices(struct Graph* g, struct VertexList* idx, struct GraphPool* gp) {
	struct VertexList* tmp = deleteEdge(g, idx->startPoint->number, idx->endPoint->number);
	dumpVertexList(gp->listPool, tmp);
	tmp = deleteEdge(g, idx->endPoint->number, idx->startPoint->number);
	if (tmp != NULL) {
		--(g->m);
	}
	dumpVertexList(gp->listPool, tmp);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq 0x10(%rsi), %rax
movq 0x18(%rsi), %rcx
movl 0x18(%rax), %esi
movl 0x18(%rcx), %edx
callq 0x7ed8
movq 0x18(%rbx), %rdi
movq %rax, %rsi
callq 0x14250
movq 0x10(%r15), %rax
movq 0x18(%r15), %rcx
movl 0x18(%rcx), %esi
movl 0x18(%rax), %edx
movq %r14, %rdi
callq 0x7ed8
testq %rax, %rax
je 0x7f88
decl 0x4(%r14)
movq 0x18(%rbx), %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x14250
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/graph.c
// Function: cloneGraph
struct Graph* cloneGraph(struct Graph* g, struct GraphPool* gp) {
	struct Graph* copy = getGraph(gp);
	int i;

	copy->activity = g->activity;
	copy->m = g->m;
	copy->n = g->n;
	copy->number = g->number;

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

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x146a9
movq %rax, %r15
movslq (%r14), %r12
movups (%r14), %xmm0
movups %xmm0, (%rax)
movq %r12, %rdi
shlq $0x3, %rdi
callq 0x1190
movq %rax, 0x10(%r15)
testl %r12d, %r12d
jle 0x80cd
xorl %r13d, %r13d
movq 0x10(%r14), %rax
movq (%rax,%r13,8), %rbp
testq %rbp, %rbp
je 0x8039
movq 0x10(%rbx), %rdi
callq 0x1447e
movl 0x18(%rbp), %ecx
movl %ecx, 0x18(%rax)
movq (%rbp), %rcx
movq %rcx, (%rax)
movq 0x10(%r15), %rcx
movq %rax, (%rcx,%r13,8)
movl (%r14), %r12d
incq %r13
movslq %r12d, %rax
cmpq %rax, %r13
jl 0x800b
testl %r12d, %r12d
jle 0x80cd
xorl %r13d, %r13d
movq 0x10(%r14), %rax
movq (%rax,%r13,8), %rax
testq %rax, %rax
je 0x80c2
movq 0x8(%rax), %rbp
testq %rbp, %rbp
je 0x80c2
movq 0x18(%rbx), %rdi
callq 0x141f1
movq 0x10(%r15), %rcx
movq 0x18(%rbp), %rdx
movslq 0x18(%rdx), %rdx
movq (%rcx,%rdx,8), %rdx
movq %rdx, 0x18(%rax)
movq 0x10(%rbp), %rdx
movslq 0x18(%rdx), %rdx
movq (%rcx,%rdx,8), %rdx
movq %rdx, 0x10(%rax)
movq (%rbp), %rdx
movq %rdx, (%rax)
movq 0x10(%rbp), %rdx
movslq 0x18(%rdx), %rdx
movq (%rcx,%rdx,8), %rsi
movq 0x8(%rsi), %rsi
movq %rsi, 0x8(%rax)
movq (%rcx,%rdx,8), %rcx
movq %rax, 0x8(%rcx)
movq 0x8(%rbp), %rbp
testq %rbp, %rbp
jne 0x8066
movl (%r14), %r12d
incq %r13
movslq %r12d, %rax
cmpq %rax, %r13
jl 0x8050
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/graph.c
// Function: getGraphEdges
struct ShallowGraph* getGraphEdges(struct Graph *g, struct ShallowGraphPool* sgp) {
	int i;
	struct ShallowGraph* edges = getShallowGraph(sgp);
	for (i=0; i<g->n; ++i) {
		if (g->vertices[i]) {
			struct VertexList *idx;
			for (idx = g->vertices[i]->neighborhood; idx; idx = idx->next) {
				if (idx->endPoint->number > i) {
					pushEdge(edges, shallowCopyEdge(idx, sgp->listPool));
				}
			}
		}
	}

	return edges;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x1498d
movq %rax, %r15
movl (%r14), %eax
testl %eax, %eax
jle 0x847d
xorl %r12d, %r12d
movq 0x10(%r14), %rcx
movq (%rcx,%r12,8), %rcx
testq %rcx, %rcx
je 0x8472
movq 0x8(%rcx), %r13
testq %r13, %r13
je 0x8472
movq 0x18(%r13), %rax
movslq 0x18(%rax), %rax
cmpq %rax, %r12
jge 0x8466
movq 0x10(%rbx), %rdi
callq 0x141f1
movups 0x10(%r13), %xmm0
movups %xmm0, 0x10(%rax)
movq (%r13), %rcx
movq %rcx, (%rax)
movq (%r15), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%r15)
cmpq $0x0, 0x8(%r15)
jne 0x8462
movq %rax, 0x8(%r15)
incl 0x10(%r15)
movq 0x8(%r13), %r13
testq %r13, %r13
jne 0x8427
movl (%r14), %eax
incq %r12
movslq %eax, %rcx
cmpq %rcx, %r12
jl 0x8411
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/graph.c
// Function: pushEdge
void pushEdge(struct ShallowGraph *g, struct VertexList *e) {

	g->edges = push(g->edges, e);
	if (g->lastEdge == NULL) {
		g->lastEdge = e;
	}
	++g->m;
}

// Assembly:
movq (%rdi), %rax
movq %rax, 0x8(%rsi)
movq %rsi, (%rdi)
cmpq $0x0, 0x8(%rdi)
jne 0x849f
movq %rsi, 0x8(%rdi)
incl 0x10(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/graph.c
// Function: addEdgeBetweenVertices
void addEdgeBetweenVertices(int v, int w, char* label, struct Graph* g, struct GraphPool* gp) {
	struct VertexList* e = getVertexList(gp->listPool);
	e->startPoint = g->vertices[v];
	e->endPoint = g->vertices[w];
	e->label = label;

	addEdge(g->vertices[v], e);
	addEdge(g->vertices[w], inverseEdge(e, gp->listPool));

	++(g->m);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %r14
movq %rcx, %rbx
movq %rdx, %r15
movl %esi, %ebp
movl %edi, %r12d
movq 0x18(%r8), %rdi
callq 0x141f1
movq %rax, %r13
movq 0x10(%rbx), %rax
movslq %r12d, %rcx
movq (%rax,%rcx,8), %rdx
movq %rdx, 0x10(%r13)
movslq %ebp, %rdx
movq (%rax,%rdx,8), %rsi
movq %rsi, 0x18(%r13)
movq %r15, (%r13)
movq (%rax,%rcx,8), %rcx
movq 0x8(%rcx), %rsi
movq %rsi, 0x8(%r13)
movq %r13, 0x8(%rcx)
movq (%rax,%rdx,8), %r15
movq 0x18(%r14), %rdi
callq 0x141f1
movq 0x18(%r13), %rcx
movq %rcx, 0x10(%rax)
movq 0x10(%r13), %rcx
movq %rcx, 0x18(%rax)
movq (%r13), %rcx
movq %rcx, (%rax)
movq 0x8(%r15), %rcx
movq %rcx, 0x8(%rax)
movq %rax, 0x8(%r15)
incl 0x4(%rbx)
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/graph.c
// Function: emptyGraph
struct Graph* emptyGraph(struct Graph* g, struct GraphPool* gp) {
	struct Graph* empty = getGraph(gp);
	int v;
	setVertexNumber(empty, g->n);

	for (v=0; v<g->n; ++v) {
		empty->vertices[v] = shallowCopyVertex(g->vertices[v], gp->vertexPool);
	}
	return empty;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x146a9
movq %rax, %r15
movl (%r14), %esi
movq %rax, %rdi
callq 0x7e6c
cmpl $0x0, (%r14)
jle 0x85d6
xorl %r12d, %r12d
movq 0x10(%r14), %rax
movq (%rax,%r12,8), %r13
movq 0x10(%rbx), %rdi
callq 0x1447e
movl 0x18(%r13), %ecx
movl %ecx, 0x18(%rax)
movq (%r13), %rcx
movq %rcx, (%rax)
movq 0x10(%r15), %rcx
movq %rax, (%rcx,%r12,8)
incq %r12
movslq (%r14), %rax
cmpq %rax, %r12
jl 0x85a4
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/graph.c
// Function: createGraph
struct Graph* createGraph(int n, struct GraphPool* gp) {
	struct Graph* empty = getGraph(gp);
	int v;
	setVertexNumber(empty, n);

	for (v=0; v<n; ++v) {
		empty->vertices[v] = getVertex(gp->vertexPool);
		empty->vertices[v]->number = v;
	}
	return empty;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movq %rsi, %rbx
movl %edi, %ebp
movq %rsi, %rdi
callq 0x146a9
movq %rax, %r14
movq %rax, %rdi
movl %ebp, %esi
callq 0x7e6c
testl %ebp, %ebp
jle 0x8634
movl %ebp, %r15d
xorl %r12d, %r12d
movq 0x10(%rbx), %rdi
callq 0x1447e
movq 0x10(%r14), %rcx
movq %rax, (%rcx,%r12,8)
movq 0x10(%r14), %rax
movq (%rax,%r12,8), %rax
movl %r12d, 0x18(%rax)
incq %r12
cmpq %r12, %r15
jne 0x860f
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/graph.c
// Function: getMaxDegree
int getMaxDegree(struct Graph* g) {
	int max = -1;
	int v;
	for (v=0; v<g->n; ++v) {
		if (g->vertices[v] != NULL) {
			int deg = degree(g->vertices[v]);
			if (max < deg) {
				max = deg;
			}
		}
	}
	return max;
}

// Assembly:
movslq (%rdi), %rcx
testq %rcx, %rcx
jle 0x867e
movq 0x10(%rdi), %rdx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
xorl %esi, %esi
movq (%rdx,%rsi,8), %rdi
testq %rdi, %rdi
je 0x8675
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
movq 0x8(%rdi), %rdi
incl %r8d
testq %rdi, %rdi
jne 0x8662
cmpl %r8d, %eax
cmovlel %r8d, %eax
incq %rsi
cmpq %rcx, %rsi
jne 0x8653
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/graph.c
// Function: getMinDegree
int getMinDegree(struct Graph* g) {
	int min = INT_MAX;
	int v;
	for (v=0; v<g->n; ++v) {
		if (g->vertices[v] != NULL) {
			int deg = degree(g->vertices[v]);
			if (min > deg) {
				min = deg;
			}
		}
	}
	return min;
}

// Assembly:
movslq (%rdi), %rcx
testq %rcx, %rcx
jle 0x86c2
movq 0x10(%rdi), %rdx
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %esi, %esi
movq (%rdx,%rsi,8), %rdi
testq %rdi, %rdi
je 0x86b9
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
movq 0x8(%rdi), %rdi
incl %r8d
testq %rdi, %rdi
jne 0x86a6
cmpl %r8d, %eax
cmovgel %r8d, %eax
incq %rsi
cmpq %rcx, %rsi
jne 0x8697
retq
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/graph.c
// Function: popGraph
struct Graph* popGraph(struct Graph** list) {
	struct Graph* head = *list;
	if (head != NULL) {
		*list = head->next;
		head->next = NULL;
	}
	return head;
}

// Assembly:
movq (%rdi), %rax
testq %rax, %rax
je 0x86df
movq 0x18(%rax), %rcx
movq %rcx, (%rdi)
movq $0x0, 0x18(%rax)
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/graph.c
// Function: canonicalizeShallowGraphCached
void canonicalizeShallowGraphCached(struct ShallowGraph* g, struct VertexList** edgePointers) {
	int i=0;
	for (struct VertexList* e=g->edges; e!=NULL; e=e->next) {
		edgePointers[i] = e;
		++i;
	}

	qsort(edgePointers, sizeof(struct VertexList*), g->m, edgeCmp);

	for (i=0; i<g->m-1; ++i) {
		edgePointers[i]->next = edgePointers[i+1];
	}
	edgePointers[g->m-1]->next = NULL;
	g->edges = edgePointers[0];

}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq (%rdi), %rax
testq %rax, %rax
je 0x8705
movq %r14, %rcx
movq %rax, (%rcx)
movq 0x8(%rax), %rax
addq $0x8, %rcx
testq %rax, %rax
jne 0x86f5
movslq 0x10(%rbx), %rdx
leaq 0x4f(%rip), %rcx        # 0x875f
movl $0x8, %esi
movq %r14, %rdi
callq 0x1080
movl 0x10(%rbx), %ecx
leal -0x1(%rcx), %eax
cmpl $0x2, %ecx
jl 0x8743
movl %eax, %ecx
movq (%r14), %rsi
xorl %edx, %edx
movq 0x8(%r14,%rdx,8), %rdi
incq %rdx
movq %rdi, 0x8(%rsi)
movq %rdi, %rsi
cmpq %rdx, %rcx
jne 0x872f
cltq
movq (%r14,%rax,8), %rax
movq $0x0, 0x8(%rax)
movq (%r14), %rax
movq %rax, (%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/graph.c
// Function: rebaseShallowGraphs
void rebaseShallowGraphs(struct ShallowGraph* list, struct Graph* newBase) {
	struct ShallowGraph* idx;
	struct VertexList* e;

	for (idx=list; idx!=NULL; idx=idx->next) {
		for (e=idx->edges; e!=NULL; e=e->next) {
			e->startPoint = newBase->vertices[e->startPoint->number];
			e->endPoint = newBase->vertices[e->endPoint->number];
		}
	}
}

// Assembly:
testq %rdi, %rdi
je 0x87f9
movq (%rdi), %rax
testq %rax, %rax
je 0x87f3
movq 0x10(%rsi), %rcx
movq 0x8(%rax), %rdx
movq 0x10(%rax), %r8
movslq 0x18(%r8), %r8
movq (%rcx,%r8,8), %r8
movq %r8, 0x10(%rax)
movq 0x18(%rax), %r8
movslq 0x18(%r8), %r8
movq (%rcx,%r8,8), %r8
movq %r8, 0x18(%rax)
movq %rdx, %rax
testq %rdx, %rdx
jne 0x87c7
movq 0x18(%rdi), %rdi
jmp 0x87b6
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/graph.c
// Function: rebaseShallowGraphsOnLowPoints
void rebaseShallowGraphsOnLowPoints(struct ShallowGraph* list, struct Graph* newBase) {
	struct ShallowGraph* idx;
	struct VertexList* e;

	for (idx=list; idx!=NULL; idx=idx->next) {
		for (e=idx->edges; e!=NULL; e=e->next) {
			e->startPoint = newBase->vertices[e->startPoint->lowPoint];
			e->endPoint = newBase->vertices[e->endPoint->lowPoint];
		}
	}
}

// Assembly:
testq %rdi, %rdi
je 0x883d
movq (%rdi), %rax
testq %rax, %rax
je 0x8837
movq 0x10(%rsi), %rcx
movq 0x8(%rax), %rdx
movq 0x10(%rax), %r8
movslq 0x20(%r8), %r8
movq (%rcx,%r8,8), %r8
movq %r8, 0x10(%rax)
movq 0x18(%rax), %r8
movslq 0x20(%r8), %r8
movq (%rcx,%r8,8), %r8
movq %r8, 0x18(%rax)
movq %rdx, %rax
testq %rdx, %rdx
jne 0x880b
movq 0x18(%rdi), %rdi
jmp 0x87fa
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/graph.c
// Function: addComponent
struct ShallowGraph* addComponent(struct ShallowGraph* g, struct ShallowGraph* h) {
	/* if g and h are both cycles, concatenate them */
	if (g && h) {	
		struct ShallowGraph* tmp = g->prev;
	
		g->prev->next = h;
		g->prev = h->prev;
		h->prev->next = g;
		h->prev = tmp;
		return g;
	} else {
		/* if one of the two inputs is NULL, return the other without change */
		return (g) ? g : h;
	}
}

// Assembly:
movq %rdi, %rax
testq %rdi, %rdi
sete %cl
testq %rsi, %rsi
sete %dl
orb %cl, %dl
jne 0x886a
movq 0x20(%rax), %rcx
movq %rsi, 0x18(%rcx)
movq 0x20(%rsi), %rdx
movq %rdx, 0x20(%rax)
movq %rax, 0x18(%rdx)
movq %rcx, 0x20(%rsi)
retq
testq %rax, %rax
cmoveq %rsi, %rax
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/graph.c
// Function: cloneShallowGraph
struct ShallowGraph* cloneShallowGraph(struct ShallowGraph* g, struct ShallowGraphPool* sgp) {
	struct ShallowGraph* copy = getShallowGraph(sgp);
	struct VertexList* edgeList = NULL;
	struct VertexList* e;
	int m = 0;
	for (e=g->edges; e!=NULL; e=e->next) {
		if (edgeList == NULL) {
			edgeList = shallowCopyEdge(e, sgp->listPool);
			copy->edges = edgeList;
		} else {
			edgeList->next = shallowCopyEdge(e, sgp->listPool);
			edgeList = edgeList->next;
		}
		++m;
	}
	copy->lastEdge = edgeList;
	copy->m = m;

	return copy;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %r14
movq %rdi, %r15
movq %rsi, %rdi
callq 0x1498d
movq %rax, %rbx
movq (%r15), %r12
testq %r12, %r12
je 0x88d4
xorl %r15d, %r15d
xorl %r13d, %r13d
movq 0x10(%r14), %rdi
callq 0x141f1
leaq 0x8(%r13), %rcx
testq %r13, %r13
movups 0x10(%r12), %xmm0
movups %xmm0, 0x10(%rax)
movq (%r12), %rdx
movq %rdx, (%rax)
cmoveq %rbx, %rcx
movq %rax, (%rcx)
incl %r15d
movq 0x8(%r12), %r12
movq %rax, %r13
testq %r12, %r12
jne 0x889a
jmp 0x88d9
xorl %eax, %eax
xorl %r15d, %r15d
movq %rax, 0x8(%rbx)
movl %r15d, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/graph.c
// Function: appendEdge
void appendEdge(struct ShallowGraph *g, struct VertexList *e) {

	if (g->lastEdge == NULL) {
		g->edges = push(g->edges, e);
		g->lastEdge = e;
	} else {
		g->lastEdge->next = e;
		e->next = NULL;
		g->lastEdge = e;
	}
	++g->m;
}

// Assembly:
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x8927
addq $0x8, %rax
xorl %ecx, %ecx
jmp 0x892d
movq (%rdi), %rcx
movq %rdi, %rax
movq %rsi, (%rax)
movq %rcx, 0x8(%rsi)
movq %rsi, 0x8(%rdi)
incl 0x10(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/graph.c
// Function: assertLastPointer
struct VertexList* assertLastPointer(struct ShallowGraph* g) {
	struct VertexList* idx;

	/* if lastedge is not initialized, set it to the first edge. */
	if (g->lastEdge == NULL) {
		g->lastEdge = g->edges;
	}

	/* move lastedge pointer to the end of the list */
	for (idx=g->lastEdge; idx; idx=idx->next) {
			g->lastEdge = idx;
	}

	return g->lastEdge;
}

// Assembly:
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
jne 0x8951
movq (%rdi), %rcx
movq %rcx, 0x8(%rdi)
testq %rcx, %rcx
je 0x8962
movq %rcx, %rax
movq %rcx, 0x8(%rdi)
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
jne 0x8951
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/graph.c
// Function: inverseCycle
struct ShallowGraph* inverseCycle(struct ShallowGraph* cycle, struct ShallowGraphPool *sgp) {
	struct VertexList *index;
	struct ShallowGraph* inverse = getShallowGraph(sgp);


	for (index=cycle->edges; index; index=index->next) {
		struct VertexList* e = inverseEdge(index, sgp->listPool);
		pushEdge(inverse, e);

		/* set lastEdge pointer to the correct value */
		if (index == cycle->edges) {
			inverse->lastEdge = e;
		}
	}

	return inverse;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x1498d
movq %rax, %r15
movq (%r14), %r12
testq %r12, %r12
je 0x89d1
movq 0x10(%rbx), %rdi
callq 0x141f1
movq 0x18(%r12), %rcx
movq %rcx, 0x10(%rax)
movq 0x10(%r12), %rcx
movq %rcx, 0x18(%rax)
movq (%r12), %rcx
movq %rcx, (%rax)
movq (%r15), %rcx
movq %rcx, 0x8(%rax)
movq %rax, (%r15)
cmpq $0x0, 0x8(%r15)
jne 0x89bd
movq %rax, 0x8(%r15)
incl 0x10(%r15)
cmpq (%r14), %r12
jne 0x89ca
movq %rax, 0x8(%r15)
movq 0x8(%r12), %r12
jmp 0x8981
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/graphPrinting.c
// Function: printGraphAidsFormat
void printGraphAidsFormat(struct Graph* g, FILE* out) {
	int i;
	// print header line
	fprintf(out, "# %i %i %i %i\n", g->number, g->activity, g->n, g->m);

	// print vertex labels
	for (i=0; i<g->n; ++i) {
		fprintf(out, "%s ", g->vertices[i]->label);
	}
	fputc('\n', out);

	// print edges
	for (i=0; i<g->n; ++i) {
		struct VertexList* e;
		for (e=g->vertices[i]->neighborhood; e!=NULL; e=e->next) {
			if (e->startPoint->number < e->endPoint->number) {
				fprintf(out, "%i %i %s ", e->startPoint->number + 1, e->endPoint->number + 1, e->label);
			}
		}
	}
	fputc('\n', out);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl 0x8(%rdi), %edx
movl 0xc(%rdi), %ecx
movl (%rdi), %r8d
movl 0x4(%rdi), %r9d
leaq 0x177d7(%rip), %rsi     # 0x201da
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1160
cmpl $0x0, (%r14)
jle 0x8a40
leaq 0x177d5(%rip), %r15     # 0x201ef
xorl %r12d, %r12d
movq 0x10(%r14), %rax
movq (%rax,%r12,8), %rax
movq (%rax), %rdx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x1160
incq %r12
movslq (%r14), %rax
cmpq %rax, %r12
jl 0x8a1d
movl $0xa, %edi
movq %rbx, %rsi
callq 0x1110
movl (%r14), %eax
testl %eax, %eax
jle 0x8aad
leaq 0x1778e(%rip), %r15     # 0x201e9
xorl %r12d, %r12d
movq 0x10(%r14), %rcx
movq (%rcx,%r12,8), %rcx
movq 0x8(%rcx), %r13
testq %r13, %r13
je 0x8aa2
movq 0x10(%r13), %rax
movq 0x18(%r13), %rcx
movl 0x18(%rax), %edx
movl 0x18(%rcx), %ecx
cmpl %ecx, %edx
jge 0x8a96
incl %edx
incl %ecx
movq (%r13), %r8
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x1160
movq 0x8(%r13), %r13
testq %r13, %r13
jne 0x8a6f
movl (%r14), %eax
incq %r12
movslq %eax, %rcx
cmpq %rcx, %r12
jl 0x8a5e
movl $0xa, %edi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1110
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/graphPrinting.c
// Function: printShallowGraph
void printShallowGraph(struct ShallowGraph* g) {
	
	struct ShallowGraph* index = g;
	int i = 0;
	do {
		if (index) {
			printf("Graph %i has %i edges:\n", i, index->m);
			printVertexList(index->edges);
			printf("\n");
			index = index->next;
			++i;
		} else {
			/* if index is NULL, the input pointed to a list and not to a cycle */
			break;
		}
	} while (index != g);
	fflush(stdout);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x8b10
movq %rdi, %rbx
leaq 0x1771a(%rip), %r14     # 0x201f3
movq %rdi, %r15
xorl %ebp, %ebp
movl 0x10(%r15), %edx
movq %r14, %rdi
movl %ebp, %esi
xorl %eax, %eax
callq 0x10b0
movq (%r15), %rdi
callq 0x8b29
movl $0xa, %edi
callq 0x1040
movq 0x18(%r15), %r15
cmpq %rbx, %r15
je 0x8b10
incl %ebp
testq %r15, %r15
jne 0x8ade
movq 0x244b1(%rip), %rax     # 0x2cfc8
movq (%rax), %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
jmp 0x11a0
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/graphPrinting.c
// Function: printVertexList
void printVertexList(struct VertexList *f) {
	struct VertexList* e;
	for (e=f; e; e=e->next) {
		printf("(%i, %i)", e->startPoint->number, e->endPoint->number);
		fflush(stdout);
		printf(" %s\n", e->label);
	}
	fflush(stdout);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x8b85
movq %rdi, %rbx
leaq 0x177e2(%rip), %r14     # 0x20322
movq 0x24481(%rip), %r12     # 0x2cfc8
leaq 0x18467(%rip), %r15     # 0x20fb5
movq 0x10(%rbx), %rax
movq 0x18(%rbx), %rcx
movl 0x18(%rax), %esi
movl 0x18(%rcx), %edx
movq %r14, %rdi
xorl %eax, %eax
callq 0x10b0
movq (%r12), %rdi
callq 0x11a0
movq (%rbx), %rsi
movq %r15, %rdi
xorl %eax, %eax
callq 0x10b0
movq 0x8(%rbx), %rbx
testq %rbx, %rbx
jne 0x8b4e
movq 0x2443c(%rip), %rax     # 0x2cfc8
movq (%rax), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x11a0
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/graphPrinting.c
// Function: printLabelledShallowGraph
void printLabelledShallowGraph(struct ShallowGraph* g) {
	
	struct ShallowGraph* index = g;
	int i = 0;
	do {
		if (index) {
			struct VertexList* e;
			printf("Graph %i has %i edges:\n", i, index->m);
			for (e=index->edges; e!=NULL; e=e->next) {
				printf("(%s)%s(%s)\n",e->startPoint->label, e->label, e->endPoint->label);
			}
			printf("\n");
			index = index->next;
			++i;
		} else {
			/* if index is NULL, the input pointed to a list and not to a cycle */
			break;
		}
	} while (index != g);
	fflush(stdout);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x8c1c
movq %rdi, %rbx
leaq 0x1763a(%rip), %r14     # 0x201f3
leaq 0x1764b(%rip), %r15     # 0x2020b
movq %rdi, %r12
xorl %ebp, %ebp
movl 0x10(%r12), %edx
movq %r14, %rdi
movl %ebp, %esi
xorl %eax, %eax
callq 0x10b0
movq (%r12), %r13
testq %r13, %r13
je 0x8c01
movq (%r13), %rdx
movq 0x10(%r13), %rax
movq (%rax), %rsi
movq 0x18(%r13), %rax
movq (%rax), %rcx
movq %r15, %rdi
xorl %eax, %eax
callq 0x10b0
movq 0x8(%r13), %r13
jmp 0x8bda
movl $0xa, %edi
callq 0x1040
movq 0x18(%r12), %r12
cmpq %rbx, %r12
je 0x8c1c
incl %ebp
testq %r12, %r12
jne 0x8bc5
movq 0x243a5(%rip), %rax     # 0x2cfc8
movq (%rax), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x11a0
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/graphPrinting.c
// Function: printShallowGraphCount
int printShallowGraphCount(struct ShallowGraph* g, char silent) {

	struct ShallowGraph* index = g;
	int i = 0;
	do {
		if (index) {
			index = index->next;
			++i;
		} else {
			/* if index is NULL, the input pointed to a list and not to a cycle */
			break;
		}
	} while (index != g);

	if (!silent) {
		printf("Result contains %i structures\n", i);
		fflush(stdout);
	}
	
	return i;

}

// Assembly:
pushq %rbx
xorl %ebx, %ebx
testq %rdi, %rdi
je 0x8c54
movq %rdi, %rax
movq 0x18(%rax), %rax
incl %ebx
cmpq %rdi, %rax
je 0x8c54
testq %rax, %rax
jne 0x8c44
testb %sil, %sil
jne 0x8c78
leaq 0x175b7(%rip), %rdi     # 0x20217
movl %ebx, %esi
xorl %eax, %eax
callq 0x10b0
movq 0x24358(%rip), %rax     # 0x2cfc8
movq (%rax), %rdi
callq 0x11a0
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/graphPrinting.c
// Function: printGraph
void printGraph(struct Graph* g) {
	
	struct Graph* index = g;
	int i= 0,j;

	do {
		if (index) {
			printf("Graph %i has id %i, %i vertices, and %i edges:\n", i, index->number, index->n, index->m);
			for (j=0; j<index->n; ++j) {
				if (index->vertices[j]) {
					printf("Vertex %i has label %s and the following neighbors:\n", index->vertices[j]->number, index->vertices[j]->label);
					printVertexList(index->vertices[j]->neighborhood);
				} else {
					printf("Vertex %i is not used by the current (induced) graph\n", j);
				}
				
			}
			printf("\n");
			index = index->next;
			++i;
		} else {
			/* if index is NULL, the input pointed to a list and not to a cycle */
			break;
		}
	} while (index != g);
	fflush(stdout);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x8d2d
movq %rdi, %r14
leaq 0x17601(%rip), %r15     # 0x2029b
leaq 0x175c5(%rip), %r12     # 0x20266
movq %rdi, %rbx
xorl %ebp, %ebp
movl 0x8(%rbx), %edx
movl (%rbx), %ecx
movl 0x4(%rbx), %r8d
leaq 0x17580(%rip), %rdi     # 0x20236
movl %ebp, %esi
xorl %eax, %eax
callq 0x10b0
cmpl $0x0, (%rbx)
jle 0x8d0f
xorl %r13d, %r13d
movq 0x10(%rbx), %rax
movq (%rax,%r13,8), %rax
testq %rax, %rax
je 0x8cf7
movl 0x18(%rax), %esi
movq (%rax), %rdx
movq %r12, %rdi
xorl %eax, %eax
callq 0x10b0
movq 0x10(%rbx), %rax
movq (%rax,%r13,8), %rax
movq 0x8(%rax), %rdi
callq 0x8b29
jmp 0x8d04
movq %r15, %rdi
movl %r13d, %esi
xorl %eax, %eax
callq 0x10b0
incq %r13
movslq (%rbx), %rax
cmpq %rax, %r13
jl 0x8cc7
movl $0xa, %edi
callq 0x1040
movq 0x18(%rbx), %rbx
cmpq %r14, %rbx
je 0x8d2d
incl %ebp
testq %rbx, %rbx
jne 0x8ca6
movq 0x24294(%rip), %rax     # 0x2cfc8
movq (%rax), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x11a0
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/graphPrinting.c
// Function: printGraphEdges
void printGraphEdges(struct Graph *g) {
	int i;
	printf("Graph has %i vertices and %i edges:\n", g->n, g->m);
	for (i=0; i<g->n; ++i) {
		if (g->vertices[i]) {
			struct VertexList *idx;
			for (idx = g->vertices[i]->neighborhood; idx; idx = idx->next) {
				if (idx->endPoint->number > i) {
					printf("(%i, %i) %s d: (%i, %i) visited: (%i,  %i)\n", idx->startPoint->number, idx->endPoint->number, idx->label, idx->startPoint->d, idx->endPoint->d, idx->startPoint->visited, idx->endPoint->visited);
				}
			}
		}
	}
	fflush(stdout);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movl (%rdi), %esi
movl 0x4(%rdi), %edx
leaq 0x17570(%rip), %rdi     # 0x202d1
xorl %eax, %eax
callq 0x10b0
movl (%rbx), %eax
testl %eax, %eax
jle 0x8de1
leaq 0x17581(%rip), %r14     # 0x202f6
xorl %r15d, %r15d
movq 0x10(%rbx), %rcx
movq (%rcx,%r15,8), %rcx
testq %rcx, %rcx
je 0x8dd6
movq 0x8(%rcx), %r12
testq %r12, %r12
je 0x8dd6
movq 0x18(%r12), %rax
movslq 0x18(%rax), %rdx
cmpq %rdx, %r15
jge 0x8dca
movq (%r12), %rcx
movq 0x10(%r12), %rdi
movl 0x28(%rdi), %r8d
movl 0x1c(%rax), %r10d
movl 0x28(%rax), %r9d
movl 0x18(%rdi), %esi
movl 0x1c(%rdi), %r11d
movq %r14, %rdi
xorl %eax, %eax
pushq %r10
pushq %r11
callq 0x10b0
addq $0x10, %rsp
movq 0x8(%r12), %r12
testq %r12, %r12
jne 0x8d8e
movl (%rbx), %eax
incq %r15
movslq %eax, %rcx
cmpq %rcx, %r15
jl 0x8d78
movq 0x241e0(%rip), %rax     # 0x2cfc8
movq (%rax), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x11a0
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/graphPrinting.c
// Function: printGraphEdgesOfTwoGraphs
void printGraphEdgesOfTwoGraphs(char* name, struct Graph *g, struct Graph* h) {
	int i;
	printf("%s 1 has %i vertices and %i edges:\n", name, g->n, g->m);
	printf("%s 2 has %i vertices and %i edges:\n", name, h->n, h->m);
	for (i=0; i<g->n; ++i) {
		printf("%i: ", i);
		if (g->vertices[i]) {
			struct VertexList *idx;
			for (idx = g->vertices[i]->neighborhood; idx; idx = idx->next) {
				printf("%i ", idx->endPoint->number);	
			}
		}
		printf("\n%i: ", i);
		if (h->vertices[i]) {
			struct VertexList *idx;
			for (idx = h->vertices[i]->neighborhood; idx; idx = idx->next) {
				printf("%i ", idx->endPoint->number);	
			}
		}
		printf("\n\n");
	}
	fflush(stdout);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movl (%rsi), %edx
movl 0x4(%rsi), %ecx
leaq 0x174cf(%rip), %rdi     # 0x2032b
movq %r15, %rsi
xorl %eax, %eax
callq 0x10b0
movl (%rbx), %edx
movl 0x4(%rbx), %ecx
leaq 0x174dd(%rip), %rdi     # 0x2034f
movq %r15, %rsi
xorl %eax, %eax
callq 0x10b0
cmpl $0x0, (%r14)
jle 0x8f2e
leaq 0x179f3(%rip), %r13     # 0x20880
leaq 0x18115(%rip), %rbp     # 0x20fa9
xorl %r15d, %r15d
leaq 0x174d6(%rip), %rdi     # 0x20374
movl %r15d, %esi
xorl %eax, %eax
callq 0x10b0
movq 0x10(%r14), %rax
movq (%rax,%r15,8), %rax
testq %rax, %rax
je 0x8ed7
movq 0x8(%rax), %r12
testq %r12, %r12
je 0x8ed7
movq 0x18(%r12), %rax
movl 0x18(%rax), %esi
movq %rbp, %rdi
xorl %eax, %eax
callq 0x10b0
movq 0x8(%r12), %r12
jmp 0x8eb9
leaq 0x17495(%rip), %rdi     # 0x20373
movl %r15d, %esi
xorl %eax, %eax
callq 0x10b0
movq 0x10(%rbx), %rax
movq (%rax,%r15,8), %rax
testq %rax, %rax
je 0x8f17
movq 0x8(%rax), %r12
testq %r12, %r12
je 0x8f17
movq 0x18(%r12), %rax
movl 0x18(%rax), %esi
movq %rbp, %rdi
xorl %eax, %eax
callq 0x10b0
movq 0x8(%r12), %r12
jmp 0x8ef9
movq %r13, %rdi
callq 0x1070
incq %r15
movslq (%r14), %rax
cmpq %rax, %r15
jl 0x8e97
movq 0x24093(%rip), %rax     # 0x2cfc8
movq (%rax), %rdi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x11a0
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/graphPrinting.c
// Function: printDirectedGraphDotFormat
void printDirectedGraphDotFormat(struct Graph* g, FILE* out) {
	fprintf(out, "digraph %i {\n", g->number);
	for (int v=0; v<g->n; ++v) {
		fprintf(out, "%i [label=%s];\n", v, g->vertices[v]->label);
	}
	for (int v=0; v<g->n; ++v) {
		for (struct VertexList* e=g->vertices[v]->neighborhood; e!=NULL; e=e->next) {
			fprintf(out, "%i -> %i [label=%s];\n", e->startPoint->number, e->endPoint->number, g->vertices[v]->label);
		}
	}
	fprintf(out, "}\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl 0x8(%rdi), %edx
leaq 0x171f6(%rip), %rsi     # 0x2039e
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1160
cmpl $0x0, (%r14)
jle 0x9248
leaq 0x17208(%rip), %r15     # 0x203cb
xorl %r12d, %r12d
movq 0x10(%r14), %rax
movq (%rax,%r12,8), %rax
movq (%rax), %rcx
movq %rbx, %rdi
movq %r15, %rsi
movl %r12d, %edx
xorl %eax, %eax
callq 0x1160
incq %r12
movslq (%r14), %rax
cmpq %rax, %r12
jl 0x91c6
testl %eax, %eax
jle 0x9248
leaq 0x171b5(%rip), %r15     # 0x203ac
xorl %r12d, %r12d
movq 0x10(%r14), %rcx
movq (%rcx,%r12,8), %rcx
movq 0x8(%rcx), %r13
testq %r13, %r13
je 0x923d
movq 0x10(%r13), %rax
movq 0x18(%r13), %rcx
movl 0x18(%rax), %edx
movl 0x18(%rcx), %ecx
movq 0x10(%r14), %rax
movq (%rax,%r12,8), %rax
movq (%rax), %r8
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x1160
movq 0x8(%r13), %r13
testq %r13, %r13
jne 0x920b
movl (%r14), %eax
incq %r12
movslq %eax, %rcx
cmpq %rcx, %r12
jl 0x91fa
leaq 0x17173(%rip), %rdi     # 0x203c2
movl $0x2, %esi
movl $0x1, %edx
movq %rbx, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1220