LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 %r9, %rbx
movq %r8, 0x10(%rsp)
movq %rcx, %r15
movl %edx, 0xc(%rsp)
movl %esi, %r13d
movq %rdi, %r12
movq (%r15), %rbp
testq %rbp, %rbp
je 0x7a3e
movq (%rbp), %rdi
movq (%rbx), %rsi
callq 0x1140
movl %eax, %r14d
movq 0x8(%rbp), %rax
movq %rax, (%r15)
testl %r14d, %r14d
je 0x7a2e
movq (%rax), %rdx
movq 0x8(%rax), %rax
movq %rax, (%r15)
movq (%rax), %rax
movq 0x10(%r12), %rcx
movslq %r13d, %r13
movq (%rcx,%r13,8), %rcx
movq %rax, (%rcx)
movl 0xc(%rsp), %edi
movl %r13d, %esi
movq %r12, %rcx
movq 0x50(%rsp), %rbp
movq %rbp, %r8
callq 0x8425
movq (%r15), %rax
movq 0x8(%rax), %rax
movq %rax, (%r15)
leal 0x1(%r13), %esi
movq %rbp, (%rsp)
movq %r12, %rdi
movl %r13d, %edx
movq %r15, %rcx
movq 0x10(%rsp), %r8
movq %rbx, %r9
callq 0x7984
movl %eax, %r13d
jmp 0x7a33
movl %r13d, 0x8(%rsp)
testl %r14d, %r14d
jne 0x79a7
jmp 0x7a43
movl %r13d, 0x8(%rsp)
movl 0x8(%rsp), %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/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 0x7060
movq %rax, %r12
movq 0x18(%rbx), %rdi
callq 0x704e
movq %rax, 0x10(%rsp)
movq (%r14), %r15
testq %r15, %r15
je 0x7abf
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 0x7a9a
incl %ebp
movq 0x8(%rsp), %r12
jmp 0x7ac4
movl $0x1, %ebp
movl %ebp, %edi
movq %rbx, %rsi
callq 0x8565
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 0x7984
movq %r15, (%r14)
movq 0x18(%rbx), %rdi
movq %r12, %rsi
callq 0x1438e
movq 0x18(%rbx), %rdi
movq %rbp, %rsi
callq 0x1438e
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_O1/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 0x7060
movq %rax, %r12
movq 0x18(%rbx), %rdi
callq 0x704e
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 0x7984
movq %rbp, (%r14)
movq 0x18(%rbx), %rdi
movq %r12, %rsi
callq 0x1438e
movq 0x18(%rbx), %rdi
movq %r13, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x1438e
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x1432b
movups 0x10(%rbx), %xmm0
movups %xmm0, 0x10(%rax)
movq (%rbx), %rcx
movq %rcx, (%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1432b
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_O1/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 0x145b2
movl 0x18(%rbx), %ecx
movl %ecx, 0x18(%rax)
movq (%rbx), %rcx
movq %rcx, (%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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), %rax
testq %rax, %rax
je 0x7c62
movq 0x18(%rax), %rcx
movl $0x1, 0x1c(%rcx)
movq 0x8(%rax), %rax
jmp 0x7c4c
movq 0x8(%rsi), %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x7c84
movq 0x18(%rcx), %rdx
movq 0x8(%rcx), %rsi
cmpl $0x1, 0x1c(%rdx)
sbbl $-0x1, %eax
movq %rsi, %rcx
testq %rsi, %rsi
jne 0x7c6d
movq 0x8(%rdi), %rcx
testq %rcx, %rcx
je 0x7c9e
movq 0x18(%rcx), %rdx
movl $0x0, 0x1c(%rdx)
movq 0x8(%rcx), %rcx
jmp 0x7c88
retq
// File: /workspace/github_c_makefile_star2_O1/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, %rcx
movq 0x8(%rdi), %rsi
movq 0x8(%rsi), %rax
cmpq %rcx, 0x18(%rsi)
je 0x7d04
testq %rax, %rax
je 0x7d03
cmpq %rcx, 0x18(%rax)
je 0x7d10
movq 0x8(%rsi), %rsi
movq 0x8(%rax), %rax
jmp 0x7cee
retq
movq %rax, 0x8(%rdi)
movq %rdx, %rdi
jmp 0x1438e
movq 0x8(%rax), %rcx
movq %rcx, 0x8(%rsi)
movq %rdx, %rdi
movq %rax, %rsi
jmp 0x1438e
// File: /workspace/github_c_makefile_star2_O1/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 0x7d49
testq %rcx, %rcx
je 0x7d46
cmpq %rsi, 0x18(%rcx)
je 0x7d4f
movq 0x8(%rax), %rax
movq 0x8(%rcx), %rcx
jmp 0x7d31
xorl %eax, %eax
retq
movq %rcx, 0x8(%rdi)
jmp 0x7d5a
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq %rcx, %rax
movq $0x0, 0x8(%rax)
retq
// File: /workspace/github_c_makefile_star2_O1/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, %rbx
movq %rdi, %r15
movq %rsi, %rdi
callq 0x147d7
movq %rax, %r14
testq %r15, %r15
je 0x7d98
xorl %esi, %esi
xorl %ebp, %ebp
movq %r15, %rax
addl (%rax), %esi
addl 0x4(%rax), %ebp
movq 0x18(%rax), %rax
testq %rax, %rax
jne 0x7d88
jmp 0x7d9c
xorl %ebp, %ebp
xorl %esi, %esi
movq %r14, %rdi
callq 0x7e30
movl %ebp, 0x4(%r14)
testq %r15, %r15
je 0x7e24
xorl %eax, %eax
movq %r15, %rcx
movslq (%rcx), %rdx
testq %rdx, %rdx
jle 0x7dfc
movslq %eax, %rsi
movl %esi, %edi
xorl %r8d, %r8d
movq 0x10(%rcx), %r9
movq (%r9,%r8,8), %r9
movq 0x10(%r14), %r10
movq %r9, (%r10,%rsi,8)
movq 0x10(%r14), %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 0x7dc2
addl %r8d, %eax
movq 0x18(%rcx), %rcx
testq %rcx, %rcx
jne 0x7db2
movq 0x18(%r15), %r12
movq $0x0, 0x18(%r15)
movq %rbx, %rdi
movq %r15, %rsi
callq 0x14832
movq %r12, %r15
testq %r12, %r12
jne 0x7e05
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 %r14
pushq %rbx
movl %esi, %ebp
testl %esi, %esi
js 0x7e73
movq %rdi, %rbx
movl %ebp, (%rdi)
movl %ebp, %r14d
leaq (,%r14,8), %rdi
callq 0x1190
movq %rax, 0x10(%rbx)
testl %ebp, %ebp
je 0x7e6d
xorl %eax, %eax
movq 0x10(%rbx), %rcx
movq $0x0, (%rcx,%rax,8)
incq %rax
cmpq %rax, %r14
jne 0x7e59
movq 0x10(%rbx), %rbx
jmp 0x7e85
leaq 0x18329(%rip), %rdi     # 0x201a3
xorl %ebx, %ebx
movl %ebp, %esi
xorl %eax, %eax
callq 0x10b0
movq %rbx, %rax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x7eaf
movq %rcx, 0x8(%rsi)
jmp 0x7ee5
testq %rcx, %rcx
je 0x7eee
movq 0x18(%rcx), %rsi
cmpl %edx, 0x18(%rsi)
jne 0x7ec2
movq %rcx, %rsi
jmp 0x7eda
movq 0x8(%rcx), %rsi
testq %rsi, %rsi
je 0x7eee
movq 0x18(%rsi), %rdi
movq %rcx, %rax
movq %rsi, %rcx
cmpl %edx, 0x18(%rdi)
jne 0x7ec2
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_O1/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 0x7e8d
movq 0x18(%rbx), %rdi
movq %rax, %rsi
callq 0x1438e
movq 0x10(%r15), %rax
movq 0x18(%r15), %rcx
movl 0x18(%rcx), %esi
movl 0x18(%rax), %edx
movq %r14, %rdi
callq 0x7e8d
testq %rax, %rax
je 0x7f3d
decl 0x4(%r14)
movq 0x18(%rbx), %rdi
movq %rax, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x1438e
// File: /workspace/github_c_makefile_star2_O1/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 %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq %rsi, %rdi
callq 0x147d7
movq %rax, %r15
movups (%r14), %xmm0
movups %xmm0, (%rax)
movslq (%r14), %r12
leaq (,%r12,8), %rdi
callq 0x1190
movq %rax, 0x10(%r15)
testq %r12, %r12
jle 0x7ff2
xorl %r12d, %r12d
movq 0x10(%r14), %rax
movq (%rax,%r12,8), %r13
testq %r13, %r13
je 0x7fe7
movq 0x10(%rbx), %rdi
callq 0x145b2
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 0x7fbb
cmpl $0x0, (%r14)
jle 0x8072
xorl %r12d, %r12d
movq 0x10(%r14), %rax
movq (%rax,%r12,8), %rax
testq %rax, %rax
je 0x8067
movq 0x8(%rax), %r13
testq %r13, %r13
je 0x8067
movq 0x18(%rbx), %rdi
callq 0x1432b
movq 0x10(%r15), %rcx
movq 0x18(%r13), %rdx
movslq 0x18(%rdx), %rdx
movq (%rcx,%rdx,8), %rdx
movq %rdx, 0x18(%rax)
movq 0x10(%r13), %rdx
movslq 0x18(%rdx), %rdx
movq (%rcx,%rdx,8), %rdx
movq %rdx, 0x10(%rax)
movq (%r13), %rdx
movq %rdx, (%rax)
movq 0x10(%r13), %rdx
movslq 0x18(%rdx), %rdx
movq (%rcx,%rdx,8), %rsi
movq 0x8(%rsi), %rsi
movq %rsi, 0x8(%rax)
movq (%rcx,%rdx,8), %rcx
movq %rax, 0x8(%rcx)
movq 0x8(%r13), %r13
jmp 0x800c
incq %r12
movslq (%r14), %rax
cmpq %rax, %r12
jl 0x7ffb
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x14aae
movq %rax, %r15
cmpl $0x0, (%r14)
jle 0x83ff
xorl %r12d, %r12d
movq 0x10(%r14), %rax
movq (%rax,%r12,8), %rax
testq %rax, %rax
je 0x83f4
movq 0x8(%rax), %r13
testq %r13, %r13
je 0x83f4
movq 0x18(%r13), %rax
movslq 0x18(%rax), %rax
cmpq %rax, %r12
jge 0x83ee
movq 0x10(%rbx), %rdi
callq 0x1432b
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 0x83ea
movq %rax, 0x8(%r15)
incl 0x10(%r15)
movq 0x8(%r13), %r13
jmp 0x83aa
incq %r12
movslq (%r14), %rax
cmpq %rax, %r12
jl 0x8399
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x8421
movq %rsi, 0x8(%rdi)
incl 0x10(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1432b
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 0x1432b
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_O1/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 0x147d7
movq %rax, %r15
movl (%r14), %esi
movq %rax, %rdi
callq 0x7e30
cmpl $0x0, (%r14)
jle 0x8558
xorl %r12d, %r12d
movq 0x10(%r14), %rax
movq (%rax,%r12,8), %r13
movq 0x10(%rbx), %rdi
callq 0x145b2
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 0x8526
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x147d7
movq %rax, %r14
movq %rax, %rdi
movl %ebp, %esi
callq 0x7e30
testl %ebp, %ebp
jle 0x85b6
movl %ebp, %r15d
xorl %r12d, %r12d
movq 0x10(%rbx), %rdi
callq 0x145b2
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 0x8591
movq %r14, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x8600
movq 0x10(%rdi), %rdx
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
xorl %esi, %esi
movq (%rdx,%rsi,8), %rdi
testq %rdi, %rdi
je 0x85f7
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
movq 0x8(%rdi), %rdi
incl %r8d
testq %rdi, %rdi
jne 0x85e4
cmpl %r8d, %eax
cmovlel %r8d, %eax
incq %rsi
cmpq %rcx, %rsi
jne 0x85d5
retq
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x8644
movq 0x10(%rdi), %rdx
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
xorl %esi, %esi
movq (%rdx,%rsi,8), %rdi
testq %rdi, %rdi
je 0x863b
movl $0xffffffff, %r8d       # imm = 0xFFFFFFFF
movq 0x8(%rdi), %rdi
incl %r8d
testq %rdi, %rdi
jne 0x8628
cmpl %r8d, %eax
cmovgel %r8d, %eax
incq %rsi
cmpq %rcx, %rsi
jne 0x8619
retq
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x8661
movq 0x18(%rax), %rcx
movq %rcx, (%rdi)
movq $0x0, 0x18(%rax)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x8687
movq %r14, %rcx
movq %rax, (%rcx)
movq 0x8(%rax), %rax
addq $0x8, %rcx
testq %rax, %rax
jne 0x8677
movslq 0x10(%rbx), %rdx
leaq 0x51(%rip), %rcx        # 0x86e3
movl $0x8, %esi
movq %r14, %rdi
callq 0x1080
movl 0x10(%rbx), %ecx
leal -0x1(%rcx), %eax
cmpl $0x2, %ecx
jl 0x86c7
movl %eax, %ecx
xorl %edx, %edx
movq (%r14,%rdx,8), %rsi
movq 0x8(%r14,%rdx,8), %rdi
leaq 0x1(%rdx), %r8
movq %rdi, 0x8(%rsi)
movq %r8, %rdx
cmpq %r8, %rcx
jne 0x86ae
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_O1/pwelke[P]GraphMiningTools/graph.c
// Function: edgeCmp
static int edgeCmp(const void* a, const void* b) {
	struct VertexList* e = *(struct VertexList**)a;
	struct VertexList* f = *(struct VertexList**)b;

	int x = e->startPoint->number - f->startPoint->number;
	int y = e->endPoint->number - f->endPoint->number;

	return x == 0 ? y : x;
}

// Assembly:
movq (%rdi), %rax
movq (%rsi), %rcx
movq 0x10(%rax), %rdx
movq 0x18(%rax), %rsi
movl 0x18(%rdx), %eax
movl 0x18(%rsi), %edx
movq 0x10(%rcx), %rsi
movq 0x18(%rcx), %rcx
subl 0x18(%rcx), %edx
subl 0x18(%rsi), %eax
cmovel %edx, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x877d
movq (%rdi), %rax
testq %rax, %rax
je 0x8777
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 0x874b
movq 0x18(%rdi), %rdi
jmp 0x873a
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x87c1
movq (%rdi), %rax
testq %rax, %rax
je 0x87bb
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 0x878f
movq 0x18(%rdi), %rdi
jmp 0x877e
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x87f2
movq 0x20(%rax), %rcx
movq %rsi, 0x18(%rcx)
movq 0x20(%rsi), %rdx
movq %rdx, 0x20(%rax)
movq 0x20(%rsi), %rdx
movq %rax, 0x18(%rdx)
movq %rcx, 0x20(%rsi)
retq
testq %rax, %rax
cmoveq %rsi, %rax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x14aae
movq %rax, %rbx
movq (%r15), %r13
testq %r13, %r13
je 0x8876
xorl %r12d, %r12d
xorl %r15d, %r15d
testq %r15, %r15
je 0x8849
movq 0x10(%r14), %rdi
callq 0x1432b
movups 0x10(%r13), %xmm0
movups %xmm0, 0x10(%rax)
movq (%r13), %rcx
movq %rcx, (%rax)
movq %rax, 0x8(%r15)
movq %rax, %r15
jmp 0x8868
movq 0x10(%r14), %rdi
callq 0x1432b
movq %rax, %r15
movups 0x10(%r13), %xmm0
movups %xmm0, 0x10(%rax)
movq (%r13), %rax
movq %rax, (%r15)
movq %r15, (%rbx)
incl %r12d
movq 0x8(%r13), %r13
testq %r13, %r13
jne 0x8822
jmp 0x887c
xorl %r15d, %r15d
xorl %r12d, %r12d
movq %r15, 0x8(%rbx)
movl %r12d, 0x10(%rbx)
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x88d0
movq %rsi, 0x8(%rax)
movq $0x0, 0x8(%rsi)
jmp 0x88da
movq (%rdi), %rax
movq %rax, 0x8(%rsi)
movq %rsi, (%rdi)
movq %rsi, 0x8(%rdi)
incl 0x10(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x14aae
movq %rax, %r15
movq (%r14), %r12
testq %r12, %r12
je 0x8974
movq 0x10(%rbx), %rdi
callq 0x1432b
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 0x8960
movq %rax, 0x8(%r15)
incl 0x10(%r15)
cmpq (%r14), %r12
jne 0x896d
movq %rax, 0x8(%r15)
movq 0x8(%r12), %r12
jmp 0x8924
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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 0x17833(%rip), %rsi     # 0x201da
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1160
cmpl $0x0, (%r14)
jle 0x89e4
leaq 0x17831(%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 0x89c1
movl $0xa, %edi
movq %rbx, %rsi
callq 0x1110
cmpl $0x0, (%r14)
jle 0x8a4a
leaq 0x177eb(%rip), %r15     # 0x201e9
xorl %r12d, %r12d
movq 0x10(%r14), %rax
movq (%rax,%r12,8), %rax
movq 0x8(%rax), %r13
testq %r13, %r13
je 0x8a3f
movq 0x10(%r13), %rax
movq 0x18(%r13), %rcx
movl 0x18(%rax), %edx
movl 0x18(%rcx), %ecx
cmpl %ecx, %edx
jge 0x8a39
incl %edx
incl %ecx
movq (%r13), %r8
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x1160
movq 0x8(%r13), %r13
jmp 0x8a0d
incq %r12
movslq (%r14), %rax
cmpq %rax, %r12
jl 0x8a01
movl $0xa, %edi
movq %rbx, %rsi
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1110
// File: /workspace/github_c_makefile_star2_O1/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 0x8aad
movq %rdi, %rbx
leaq 0x1777d(%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 0x8ac6
movl $0xa, %edi
callq 0x1040
movq 0x18(%r15), %r15
cmpq %rbx, %r15
je 0x8aad
incl %ebp
testq %r15, %r15
jne 0x8a7b
movq 0x24514(%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_O1/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 0x8b22
movq %rdi, %rbx
leaq 0x17845(%rip), %r14     # 0x20322
movq 0x244e4(%rip), %r12     # 0x2cfc8
leaq 0x184ca(%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 0x8aeb
movq 0x2449f(%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_O1/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 0x8bb9
movq %rdi, %rbx
leaq 0x1769d(%rip), %r14     # 0x201f3
leaq 0x176ae(%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 0x8b9e
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 0x8b77
movl $0xa, %edi
callq 0x1040
movq 0x18(%r12), %r12
cmpq %rbx, %r12
je 0x8bb9
incl %ebp
testq %r12, %r12
jne 0x8b62
movq 0x24408(%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_O1/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 0x8bf1
movq %rdi, %rax
movq 0x18(%rax), %rax
incl %ebx
cmpq %rdi, %rax
je 0x8bf1
testq %rax, %rax
jne 0x8be1
testb %sil, %sil
jne 0x8c15
leaq 0x1761a(%rip), %rdi     # 0x20217
movl %ebx, %esi
xorl %eax, %eax
callq 0x10b0
movq 0x243bb(%rip), %rax     # 0x2cfc8
movq (%rax), %rdi
callq 0x11a0
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x8cca
movq %rdi, %r14
leaq 0x17664(%rip), %r15     # 0x2029b
leaq 0x17628(%rip), %r12     # 0x20266
movq %rdi, %rbx
xorl %ebp, %ebp
movl 0x8(%rbx), %edx
movl (%rbx), %ecx
movl 0x4(%rbx), %r8d
leaq 0x175e3(%rip), %rdi     # 0x20236
movl %ebp, %esi
xorl %eax, %eax
callq 0x10b0
cmpl $0x0, (%rbx)
jle 0x8cac
xorl %r13d, %r13d
movq 0x10(%rbx), %rax
movq (%rax,%r13,8), %rax
testq %rax, %rax
je 0x8c94
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 0x8ac6
jmp 0x8ca1
movq %r15, %rdi
movl %r13d, %esi
xorl %eax, %eax
callq 0x10b0
incq %r13
movslq (%rbx), %rax
cmpq %rax, %r13
jl 0x8c64
movl $0xa, %edi
callq 0x1040
movq 0x18(%rbx), %rbx
cmpq %r14, %rbx
je 0x8cca
incl %ebp
testq %rbx, %rbx
jne 0x8c43
movq 0x242f7(%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_O1/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 0x175d3(%rip), %rdi     # 0x202d1
xorl %eax, %eax
callq 0x10b0
cmpl $0x0, (%rbx)
jle 0x8d78
leaq 0x175e5(%rip), %r14     # 0x202f6
xorl %r15d, %r15d
movq 0x10(%rbx), %rax
movq (%rax,%r15,8), %rax
testq %rax, %rax
je 0x8d6d
movq 0x8(%rax), %r12
testq %r12, %r12
je 0x8d6d
movq 0x18(%r12), %rax
movslq 0x18(%rax), %rdx
cmpq %rdx, %r15
jge 0x8d66
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
jmp 0x8d25
incq %r15
movslq (%rbx), %rax
cmpq %rax, %r15
jl 0x8d14
movq 0x24249(%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_O1/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 0x17538(%rip), %rdi     # 0x2032b
movq %r15, %rsi
xorl %eax, %eax
callq 0x10b0
movl (%rbx), %edx
movl 0x4(%rbx), %ecx
leaq 0x17546(%rip), %rdi     # 0x2034f
movq %r15, %rsi
xorl %eax, %eax
callq 0x10b0
cmpl $0x0, (%r14)
jle 0x8ec5
leaq 0x17a5c(%rip), %r13     # 0x20880
leaq 0x1817e(%rip), %rbp     # 0x20fa9
xorl %r15d, %r15d
leaq 0x1753f(%rip), %rdi     # 0x20374
movl %r15d, %esi
xorl %eax, %eax
callq 0x10b0
movq 0x10(%r14), %rax
movq (%rax,%r15,8), %rax
testq %rax, %rax
je 0x8e6e
movq 0x8(%rax), %r12
testq %r12, %r12
je 0x8e6e
movq 0x18(%r12), %rax
movl 0x18(%rax), %esi
movq %rbp, %rdi
xorl %eax, %eax
callq 0x10b0
movq 0x8(%r12), %r12
jmp 0x8e50
leaq 0x174fe(%rip), %rdi     # 0x20373
movl %r15d, %esi
xorl %eax, %eax
callq 0x10b0
movq 0x10(%rbx), %rax
movq (%rax,%r15,8), %rax
testq %rax, %rax
je 0x8eae
movq 0x8(%rax), %r12
testq %r12, %r12
je 0x8eae
movq 0x18(%r12), %rax
movl 0x18(%rax), %esi
movq %rbp, %rdi
xorl %eax, %eax
callq 0x10b0
movq 0x8(%r12), %r12
jmp 0x8e90
movq %r13, %rdi
callq 0x1070
incq %r15
movslq (%r14), %rax
cmpq %rax, %r15
jl 0x8e2e
movq 0x240fc(%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_O1/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 0x1724b(%rip), %rsi     # 0x2039e
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1160
cmpl $0x0, (%r14)
jle 0x9193
leaq 0x17261(%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 0x916d
cmpl $0x0, (%r14)
jle 0x91eb
leaq 0x1720c(%rip), %r15     # 0x203ac
xorl %r12d, %r12d
movq 0x10(%r14), %rax
movq (%rax,%r12,8), %rax
movq 0x8(%rax), %r13
testq %r13, %r13
je 0x91e0
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
jmp 0x91af
incq %r12
movslq (%r14), %rax
cmpq %rax, %r12
jl 0x91a3
leaq 0x171d0(%rip), %rdi     # 0x203c2
movl $0x2, %esi
movl $0x1, %edx
movq %rbx, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1220
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/graphPrinting.c
// Function: printGraphDotFormat
void printGraphDotFormat(struct Graph* g, FILE* out) {
	fprintf(out, "graph %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) {
			if (e->startPoint->number < e->endPoint->number) {
				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 0x1717a(%rip), %rsi     # 0x203a0
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1160
cmpl $0x0, (%r14)
jle 0x9266
leaq 0x1718e(%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 0x9240
cmpl $0x0, (%r14)
jle 0x92c2
leaq 0x17152(%rip), %r15     # 0x203c5
xorl %r12d, %r12d
movq 0x10(%r14), %rax
movq (%rax,%r12,8), %rax
movq 0x8(%rax), %r13
testq %r13, %r13
je 0x92b7
movq 0x10(%r13), %rax
movq 0x18(%r13), %rcx
movl 0x18(%rax), %edx
movl 0x18(%rcx), %ecx
cmpl %ecx, %edx
jge 0x92b1
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
jmp 0x9282
incq %r12
movslq (%r14), %rax
cmpq %rax, %r12
jl 0x9276
leaq 0x170f9(%rip), %rdi     # 0x203c2
movl $0x2, %esi
movl $0x1, %edx
movq %rbx, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1220
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/importantSubtrees.c
// Function: graph2ComponentCleanup
void graph2ComponentCleanup(struct Graph* g, struct Graph* components, struct GraphPool* gp) {
	for (struct Graph* c=components; c!=NULL; c=c->next) {
		for (int v=0; v<c->n; ++v) {
			c->vertices[v] = NULL;
		}
		c->n = 0;
	}
	dumpGraphList(gp, components);
	for (int v=0; v<g->n; ++v) {
		g->vertices[v]->number = v;
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
testq %rsi, %rsi
je 0x979e
movq %rsi, %rax
movslq (%rax), %rcx
testq %rcx, %rcx
jle 0x978f
xorl %edi, %edi
movq 0x10(%rax), %r8
movq $0x0, (%r8,%rdi,8)
incq %rdi
cmpq %rdi, %rcx
jne 0x977b
movl $0x0, (%rax)
movq 0x18(%rax), %rax
testq %rax, %rax
jne 0x9771
movq %rdx, %rdi
callq 0x148f4
movslq (%rbx), %rax
testq %rax, %rax
jle 0x97c3
movq 0x10(%rbx), %rcx
xorl %edx, %edx
movq (%rcx,%rdx,8), %rsi
movl %edx, 0x18(%rsi)
incq %rdx
cmpq %rdx, %rax
jne 0x97b4
popq %rbx
retq