LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/treeEnumeration.c
// Function: extendPatternOnLeaves
struct Graph* extendPatternOnLeaves(struct Graph* g, struct ShallowGraph* candidateEdges, struct GraphPool* gp) {

	struct Graph* rho = NULL;

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

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movslq (%rdi), %rax
testq %rax, %rax
jle 0x1d815
movq 0x10(%r15), %rcx
xorl %edx, %edx
movq (%rcx,%rdx,8), %rsi
movl $0x0, 0x1c(%rsi)
incq %rdx
cmpq %rdx, %rax
jne 0x1d802
cmpl $0x0, (%r15)
jle 0x1d868
xorl %r12d, %r12d
movl $0x1, %ebp
movq 0x10(%r15), %rax
movq (%rax,%r12,8), %rdi
callq 0x7c33
testb %al, %al
je 0x1d84a
movq 0x10(%r15), %rax
movq (%rax,%r12,8), %rax
movl %ebp, 0x1c(%rax)
movq 0x8(%rax), %rax
movq 0x18(%rax), %rax
movl %ebp, 0x1c(%rax)
incq %r12
movslq (%r15), %rax
cmpq %rax, %r12
jl 0x1d823
cmpl $0x1, %eax
jne 0x1d868
movq 0x10(%r15), %rax
movq (%rax), %rax
movl $0x1, 0x1c(%rax)
cmpl $0x0, (%r15)
jle 0x1d8d0
xorl %r13d, %r13d
xorl %r12d, %r12d
movq 0x10(%r15), %rax
movq (%rax,%r13,8), %rax
cmpl $0x0, 0x1c(%rax)
je 0x1d8c3
movq (%r14), %rbp
testq %rbp, %rbp
je 0x1d8c3
movq 0x10(%r15), %rax
movq (%rax,%r13,8), %rax
movq (%rax), %rdi
movq 0x10(%rbp), %rax
movq (%rax), %rsi
callq 0x1140
testl %eax, %eax
jne 0x1d8bd
movq %r15, %rdi
movl %r13d, %esi
movq %rbp, %rdx
movq %rbx, %rcx
callq 0x1d618
movq %r12, 0x18(%rax)
movq %rax, %r12
movq 0x8(%rbp), %rbp
jmp 0x1d885
incq %r13
movslq (%r15), %rax
cmpq %rax, %r13
jl 0x1d874
jmp 0x1d8d3
xorl %r12d, %r12d
movq %r12, %rax
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/treeEnumeration.c
// Function: extendPatternOnOuterShells
struct Graph* extendPatternOnOuterShells(struct Graph* g, struct ShallowGraph* candidateEdges, struct GraphPool* gp, struct ShallowGraphPool* sgp) {

	struct Graph* rho = NULL;

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, (%rsp)
movq %rdi, %r15
movq %rcx, %rsi
callq 0x1d50a
cmpl $0x0, (%r15)
jle 0x1d971
movl %eax, %ebp
decl %ebp
xorl %r13d, %r13d
xorl %r12d, %r12d
movq 0x10(%r15), %rax
movq (%rax,%r13,8), %rax
cmpl %ebp, 0x20(%rax)
jge 0x1d92c
incq %r13
movslq (%r15), %rax
cmpq %rax, %r13
jl 0x1d912
jmp 0x1d974
movq (%rsp), %rax
movq (%rax), %r14
testq %r14, %r14
je 0x1d91f
movq 0x10(%r15), %rax
movq (%rax,%r13,8), %rax
movq (%rax), %rdi
movq 0x10(%r14), %rax
movq (%rax), %rsi
callq 0x1140
testl %eax, %eax
jne 0x1d96b
movq %r15, %rdi
movl %r13d, %esi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x1d618
movq %r12, 0x18(%rax)
movq %rax, %r12
movq 0x8(%r14), %r14
jmp 0x1d933
xorl %r12d, %r12d
movq %r12, %rax
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/treeEnumeration.c
// Function: basicFilter
struct Graph* basicFilter(struct Graph* extension, struct Vertex* listOfGraphs, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	struct Graph* result = NULL;
	struct Graph* g = extension;
	while (g != NULL) {
		// store second element, detach head
		struct Graph* tmp = g->next;
		g->next = NULL;

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
testq %rdi, %rdi
je 0x1da12
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r13
movq $0x0, (%rsp)
movq 0x18(%r13), %r12
movq $0x0, 0x18(%r13)
movq %r13, %rdi
movq %rbx, %rsi
callq 0x78fc
movq %rax, %rbp
movq %r15, %rdi
movq %rax, %rsi
callq 0x1adff
testb %al, %al
je 0x1d9eb
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x14b19
movq %r14, %rdi
movq %r13, %rsi
callq 0x14832
jmp 0x1da08
movq %r15, %rdi
movq %rbp, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x1af0f
movq (%rsp), %rax
movq %rax, 0x18(%r13)
movq %r13, (%rsp)
movq %r12, %r13
testq %r12, %r12
jne 0x1d9aa
jmp 0x1da1a
movq $0x0, (%rsp)
movq (%rsp), %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/treeEnumerationRooted.c
// Function: extendRootedPatternAllWays
struct Graph* extendRootedPatternAllWays(struct Graph* g, struct ShallowGraph* candidateEdges, struct GraphPool* gp) {
	struct Graph* rho = NULL;
	struct VertexList* e;
	for (e=candidateEdges->edges; e!=NULL; e=e->next) {
		int v;
		for (v=0; v<g->n; ++v) {
			/* if the labels are compatible */
			if (strcmp(g->vertices[v]->label, e->startPoint->label) == 0) {
				struct Graph* h = refinementGraph(g, v, e, gp);
				h->next = rho;
				rho = h;
			}
		}
	}
	return rho;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq (%rsi), %r12
testq %r12, %r12
je 0x1dc36
movq %rdx, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
cmpl $0x0, (%r14)
jle 0x1dc2a
xorl %r13d, %r13d
movq 0x10(%r14), %rax
movq (%rax,%r13,8), %rax
movq (%rax), %rdi
movq 0x10(%r12), %rax
movq (%rax), %rsi
callq 0x1140
testl %eax, %eax
jne 0x1dc1f
movq %r14, %rdi
movl %r13d, %esi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x1d618
movq %r15, 0x18(%rax)
movq %rax, %r15
incq %r13
movslq (%r14), %rax
cmpq %rax, %r13
jl 0x1dbeb
movq 0x8(%r12), %r12
testq %r12, %r12
jne 0x1dbe2
jmp 0x1dc39
xorl %r15d, %r15d
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/treeKernels.c
// Function: cleanUpEdgeSort
void cleanUpEdgeSort(struct Vertex* v, struct ShallowGraphPool* sgp) {
	struct VertexList* e;
	struct VertexList* f;
	struct VertexList* first = getVertexList(sgp->listPool);
	struct ShallowGraph* fifo = getShallowGraph(sgp);

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

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


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

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

			dumpVertexList(sgp->listPool, e);

	}

	dumpShallowGraph(sgp, fifo);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movq 0x10(%rsi), %rdi
callq 0x1432b
movq %rax, %r12
movq %rbx, %rdi
callq 0x14aae
movq %rax, %r14
movq %r15, 0x18(%r12)
movq %r15, 0x10(%r12)
movq %rax, %rdi
movq %r12, %rsi
callq 0x88b9
movq %r14, %rdi
callq 0x8891
testq %rax, %rax
je 0x1de8b
movq %rax, %r15
movq 0x18(%r15), %rax
movl $0x0, 0x1c(%rax)
movq 0x8(%rax), %r12
testq %r12, %r12
je 0x1de6f
movq 0x18(%r12), %rax
cmpl $0x0, 0x1c(%rax)
je 0x1de68
movq 0x10(%rbx), %rsi
movq %r12, %rdi
callq 0x7bc0
movq %r14, %rdi
movq %rax, %rsi
callq 0x88b9
movq 0x8(%r12), %r12
jmp 0x1de41
movq 0x10(%rbx), %rdi
movq %r15, %rsi
callq 0x1438e
movq %r14, %rdi
callq 0x8891
movq %rax, %r15
testq %rax, %rax
jne 0x1de32
movq %rbx, %rdi
movq %r14, %rsi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x14b19
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/treeKernels.c
// Function: edgeSort
struct ShallowGraph* edgeSort(struct Vertex* v, int maxDepth, struct ShallowGraphPool* sgp) {
	struct VertexList* e;
	struct VertexList* f;
	struct VertexList* first = getVertexList(sgp->listPool);
	struct ShallowGraph* output = getShallowGraph(sgp);
	struct ShallowGraph* fifo = getShallowGraph(sgp);

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

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

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

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

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

	dumpShallowGraph(sgp, fifo);

	return output;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r12
movq 0x10(%rdx), %rdi
callq 0x1432b
movq %rax, %r13
movq %rbx, %rdi
callq 0x14aae
movq %rax, %r14
movq %rbx, %rdi
callq 0x14aae
movq %rax, %r15
movq %r12, 0x18(%r13)
movq %r12, 0x10(%r13)
movq %rax, %rdi
movq %r13, %rsi
callq 0x88b9
movq %r15, %rdi
callq 0x8891
testq %rax, %rax
je 0x1df6f
movq %rax, %r12
movq 0x10(%r12), %rax
movl 0x1c(%rax), %eax
cmpl %ebp, %eax
jg 0x1df63
incl %eax
movq 0x18(%r12), %rcx
movl %eax, 0x1c(%rcx)
movq %r14, %rdi
movq %r12, %rsi
callq 0x88b9
movq 0x18(%r12), %rax
movq 0x8(%rax), %r12
testq %r12, %r12
je 0x1df51
movq 0x18(%r12), %rax
cmpl $0x0, 0x1c(%rax)
jne 0x1df4a
movq 0x10(%rbx), %rsi
movq %r12, %rdi
callq 0x7bc0
movq %r15, %rdi
movq %rax, %rsi
callq 0x88b9
movq 0x8(%r12), %r12
jmp 0x1df23
movq %r15, %rdi
callq 0x8891
movq %rax, %r12
testq %rax, %rax
jne 0x1def9
jmp 0x1df6f
movq 0x10(%rbx), %rdi
movq %r12, %rsi
callq 0x1438e
movq %rbx, %rdi
movq %r15, %rsi
callq 0x14b19
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/treeKernels.c
// Function: bfsSubtreeEnumeration
struct ShallowGraph* bfsSubtreeEnumeration(struct Graph* t, int maxDepth, struct ShallowGraphPool* sgp) {
	int i;
	struct ShallowGraph* results = NULL;

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

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

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
cmpl $0x0, (%rdi)
jle 0x1e07c
movl %esi, %ebp
movq %rdi, %rcx
xorl %ebx, %ebx
xorl %r15d, %r15d
movq %rdx, 0x18(%rsp)
movq 0x10(%rcx), %rax
movq (%rax,%rbx,8), %rdi
testq %rdi, %rdi
je 0x1e06b
movq %rbx, 0x10(%rsp)
movq %rcx, %r12
movl %ebp, %esi
callq 0x1dea1
movq %rax, 0x20(%rsp)
movq 0x8(%rax), %rax
movq 0x18(%rax), %rax
movl 0x1c(%rax), %eax
cmpl %eax, %ebp
cmovll %ebp, %eax
testl %eax, %eax
movl %eax, 0xc(%rsp)
jle 0x1e033
movl %eax, %r14d
negl %r14d
movl $0x1, %ebp
movq 0x10(%rsp), %rbx
movq 0x10(%r12), %rax
movq (%rax,%rbx,8), %rdi
xorl %esi, %esi
movl %ebp, %edx
movq 0x18(%rsp), %rcx
callq 0x750d
movq %rax, %r13
movq %r15, 0x18(%rax)
leal (%r14,%rbp), %eax
incl %eax
movl %ebp, %ecx
incl %ecx
movl %ecx, %ebp
movq %r13, %r15
cmpl $0x1, %eax
jne 0x1dfff
jmp 0x1e03b
movq %r15, %r13
movq 0x10(%rsp), %rbx
movq 0x10(%r12), %rax
movq (%rax,%rbx,8), %rdi
movq 0x18(%rsp), %r14
movq %r14, %rsi
callq 0x1dde8
movq %r14, %rdi
movq 0x20(%rsp), %rsi
callq 0x14b19
movq %r13, %r15
movl 0xc(%rsp), %ebp
movq %r14, %rdx
movq %r12, %rcx
incq %rbx
movslq (%rcx), %rax
cmpq %rax, %rbx
jl 0x1dfb2
jmp 0x1e07f
xorl %r15d, %r15d
movq %r15, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/treeKernels.c
// Function: fullSubtreeEnumeration
int fullSubtreeEnumeration(struct Graph* t, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	int numberOfTrees = 0;

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

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

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


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

	return numberOfTrees;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rdx, %r14
movq %rsi, %rbx
movq %rdi, %rbp
movl $0x0, 0xc(%rsp)
movq %rdx, %rsi
callq 0x8376
movq %rax, 0x10(%rsp)
movq %r14, %rdi
callq 0x14aae
movq %rax, %r12
movq %rbx, %rdi
callq 0x147d7
movq %rax, %r13
movl (%rbp), %esi
movq %rax, %rdi
callq 0x7e30
cmpl $0x0, (%rbp)
jle 0x1e3e3
xorl %r15d, %r15d
movq 0x10(%rbp), %rax
movq (%rax,%r15,8), %rdi
movq 0x10(%rbx), %rsi
callq 0x7c08
movq 0x10(%r13), %rcx
movq %rax, (%rcx,%r15,8)
incq %r15
movslq (%rbp), %rax
cmpq %rax, %r15
jl 0x1e3be
leaq 0xc(%rsp), %rbp
movq %r13, %rdi
movq %r12, %rsi
movq 0x10(%rsp), %r15
movq %r15, %rdx
movq %rbp, %rcx
movq %r14, %r8
callq 0x1e182
movq %r14, %rdi
movq %r15, %rsi
callq 0x14b19
movq %r14, %rdi
movq %r12, %rsi
callq 0x14b19
movq %rbx, %rdi
movq %r13, %rsi
callq 0x14832
movl (%rbp), %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/upperBoundsForSpanningTrees.c
// Function: nCr
long nCr(long n, long r) {
	long numer = 1;
	long denom = 1;
	int i;
	if (n - r < r) {
		r = n - r;
	}
	if (r == 0) {
		return 1;
	}
	for (i=n; i>n-r; --i) {
		numer *= i;
	}
	for (i=1; i<r+1; ++i) {
		denom *= i;
	}
	return numer / denom;
}

// Assembly:
movq %rdi, %rcx
subq %rsi, %rcx
cmpq %rsi, %rcx
cmovgeq %rsi, %rcx
testq %rcx, %rcx
je 0x1e493
movq %rdi, %rdx
subq %rcx, %rdx
movslq %edi, %rdi
movl $0x1, %esi
movl $0x1, %eax
cmpq %rdi, %rdx
jge 0x1e467
imulq %rdi, %rax
decq %rdi
jmp 0x1e459
testq %rcx, %rcx
jle 0x1e48d
negq %rcx
movl $0x1, %edx
movl $0x1, %esi
imulq %rdx, %rsi
leaq (%rcx,%rdx), %rdi
incq %rdi
incq %rdx
cmpq $0x1, %rdi
jne 0x1e479
cqto
idivq %rsi
retq
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/upperBoundsForSpanningTrees.c
// Function: nCr2
long nCr2(long n, long r) {
	long numer = 1;
	long denom = 1;
	int i;
	if (n - r < r) {
		r = n - r;
	}
	if (r == 0) {
		return 1;
	}
	for (i=n; i>n-r; --i) {
		/* avoid overflowing */
		if (numer >= LONG_MAX / i) {
			return -1;
		}
		numer *= i;
	}
	/* r! is always smaller than (n-r)*...*(r+1) */
	for (i=1; i<r+1; ++i) {
		denom *= i;
	}
	return numer / denom;
}

// Assembly:
movq %rdi, %r8
subq %rsi, %r8
cmpq %rsi, %r8
cmovgeq %rsi, %r8
testq %r8, %r8
je 0x1e515
movq %rdi, %r9
subq %r8, %r9
movslq %edi, %r10
movl $0x1, %edi
movl $0x1, %ecx
cmpq %r10, %r9
jge 0x1e4e6
movabsq $0x7fffffffffffffff, %rsi # imm = 0x7FFFFFFFFFFFFFFF
movq %rsi, %rax
xorl %edx, %edx
idivq %r10
cmpq %rax, %rcx
jge 0x1e51b
imulq %r10, %rcx
decq %r10
cmpq %r10, %r9
jl 0x1e4cd
testq %r8, %r8
jle 0x1e50c
negq %r8
movl $0x1, %eax
movl $0x1, %edi
imulq %rax, %rdi
leaq (%r8,%rax), %rdx
incq %rdx
incq %rax
cmpq $0x1, %rdx
jne 0x1e4f8
movq %rcx, %rax
cqto
idivq %rdi
retq
movl $0x1, %eax
retq
movq $-0x1, %rax
retq
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/upperBoundsForSpanningTrees.c
// Function: outerplanarBound
long outerplanarBound(long m, long n) {
	double estimate = 0.0;
	long i;
	long k = m-n;
	for (i=0; i<k+1; ++i) {
		double mean = n / (double)(i+1);
		double meanPot = 1.0;
		int j;
		long bin;

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
subq %rsi, %rbx
cvtsi2sd %rsi, %xmm3
movq $-0x1, %r14
cmovnsq %rbx, %r14
incq %r14
xorpd %xmm2, %xmm2
movl $0x1, %r15d
xorl %r12d, %r12d
movsd 0x27d4(%rip), %xmm4     # 0x20d38
movsd 0x2b64(%rip), %xmm5     # 0x210d0
movsd %xmm3, (%rsp)
cmpq %r14, %r12
je 0x1e610
movq %r12, %rsi
incq %r12
xorps %xmm1, %xmm1
cvtsi2sd %r12, %xmm1
movapd %xmm3, %xmm0
divsd %xmm1, %xmm0
movq %r15, %rax
movapd %xmm4, %xmm1
mulsd %xmm0, %xmm1
decq %rax
jne 0x1e597
ucomisd %xmm5, %xmm1
jae 0x1e5db
movsd %xmm1, 0x8(%rsp)
movapd %xmm2, 0x10(%rsp)
movq %rbx, %rdi
callq 0x1e499
testq %rax, %rax
js 0x1e5df
xorps %xmm0, %xmm0
cvtsi2sd %rax, %xmm0
mulsd 0x8(%rsp), %xmm0
movapd 0x10(%rsp), %xmm2
addsd %xmm0, %xmm2
movb $0x1, %al
jmp 0x1e5e7
xorl %eax, %eax
jmp 0x1e5fc
xorl %eax, %eax
movapd 0x10(%rsp), %xmm2
movsd (%rsp), %xmm3
movsd 0x2744(%rip), %xmm4     # 0x20d38
movsd 0x2ad4(%rip), %xmm5     # 0x210d0
incq %r15
testb %al, %al
jne 0x1e571
movq $-0x1, %rax
jmp 0x1e640
movq $-0x1, %rax
ucomisd 0x2ab9(%rip), %xmm2     # 0x210d8
ja 0x1e640
cvttsd2si %xmm2, %rcx
movq %rcx, %rdx
sarq $0x3f, %rdx
subsd 0x2aa3(%rip), %xmm2     # 0x210d8
cvttsd2si %xmm2, %rax
andq %rdx, %rax
orq %rcx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/upperBoundsForSpanningTrees.c
// Function: getVertexNumberOfInducedGraph
int getVertexNumberOfInducedGraph(struct ShallowGraph* g, int n, int* vertices) {
	int i;
	struct VertexList* e;
	int nInd = 0;
	for(i=0; i<n; ++i) { vertices[i] = 0; }
	for(e=g->edges; e!=NULL; e=e->next) {
		vertices[e->startPoint->number] = 1;
		vertices[e->endPoint->number] = 1;
	}
	for (i=0; i<n; ++i) {
		if (vertices[i] != 0) {
			++nInd;
		}
	}
	return nInd;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movl %esi, %ebp
movq %rdi, %r14
movl %esi, %r15d
testl %esi, %esi
jle 0x1e674
leaq (,%r15,4), %rdx
movq %rbx, %rdi
xorl %esi, %esi
callq 0x10d0
movq (%r14), %rax
testq %rax, %rax
je 0x1e6a0
movl $0x1, %ecx
movq 0x10(%rax), %rdx
movslq 0x18(%rdx), %rdx
movl %ecx, (%rbx,%rdx,4)
movq 0x18(%rax), %rdx
movslq 0x18(%rdx), %rdx
movl %ecx, (%rbx,%rdx,4)
movq 0x8(%rax), %rax
testq %rax, %rax
jne 0x1e681
testl %ebp, %ebp
jle 0x1e6b9
xorl %ecx, %ecx
xorl %eax, %eax
cmpl $0x1, (%rbx,%rcx,4)
sbbl $-0x1, %eax
incq %rcx
cmpq %rcx, %r15
jne 0x1e6a8
jmp 0x1e6bb
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/upperBoundsForSpanningTrees.c
// Function: getGoodEstimate
long int getGoodEstimate(struct Graph* g, struct ShallowGraphPool* sgp, struct GraphPool* gp) {
	struct ShallowGraph* biconnectedComponents = listBiconnectedComponents(g, sgp);
	long int estimate = getGoodEstimatePrecomputedBlocks(g, biconnectedComponents, sgp, gp);
	dumpShallowGraphCycle(sgp, biconnectedComponents);
	return estimate;
}

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, (%rsp)
movq %rdx, %r14
movq %rsi, %r12
movq %rdi, %r13
movslq (%rdi), %rdi
shlq $0x2, %rdi
callq 0x1190
movq %rax, %rbp
movl $0x1, %r15d
testq %r12, %r12
je 0x1e7b0
cmpl $0x1, 0x10(%r12)
je 0x1e7a9
movl (%r13), %esi
movq %r12, %rdi
movq %rbp, %rdx
callq 0x1e64c
movl %eax, %ebx
movq %r12, %rdi
movq %r14, %rsi
movq (%rsp), %rdx
callq 0x16e9b
movslq 0x10(%r12), %rdi
movslq %ebx, %rsi
testb %al, %al
je 0x1e77a
callq 0x1e52b
jmp 0x1e782
decq %rsi
callq 0x1e499
movq %rax, %rbx
cmpq $-0x1, %rax
je 0x1e791
imulq %rbx, %r15
jmp 0x1e799
movq %rbp, %rdi
callq 0x1030
cmpq $-0x1, %rbx
je 0x1e7a3
movb $0x1, %al
jmp 0x1e7a5
xorl %eax, %eax
testb %al, %al
je 0x1e7ba
movq 0x18(%r12), %r12
jmp 0x1e73a
movq %rbp, %rdi
callq 0x1030
jmp 0x1e7c1
movq $-0x1, %r15
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_O1/pwelke[P]GraphMiningTools/upperBoundsForSpanningTrees.c
// Function: getEstimate
long int getEstimate(struct Graph* g, long int estimateFunction(long int, long int), char checkOuterplanarity, struct ShallowGraphPool* sgp, struct GraphPool* gp) {
	struct ShallowGraph* biconnectedComponents = listBiconnectedComponents(g, sgp);
	struct ShallowGraph* idx;
	long int estimate = 1;
	int* vertices = malloc(g->n * sizeof(int));

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %r8, 0x8(%rsp)
movq %rcx, %rbx
movl %edx, %ebp
movq %rsi, 0x10(%rsp)
movq %rdi, %r13
movq %rcx, %rsi
callq 0xb2bf
movq %rax, %r12
movslq (%r13), %rdi
shlq $0x2, %rdi
callq 0x1190
movq %rax, %r14
testq %r12, %r12
movq %r12, (%rsp)
movl $0x1, %r15d
je 0x1e87d
cmpl $0x1, 0x10(%r12)
je 0x1e873
testb %bpl, %bpl
je 0x1e83e
movq %r12, %rdi
movq %rbx, %rsi
movq 0x8(%rsp), %rdx
callq 0x16e9b
testb %al, %al
je 0x1e861
movl (%r13), %esi
movq %r12, %rdi
movq %r14, %rdx
callq 0x1e64c
movslq 0x10(%r12), %rdi
movslq %eax, %rsi
callq *0x10(%rsp)
imulq %rax, %r15
movb $0x1, %al
jmp 0x1e86f
movq %rbx, %rdi
movq (%rsp), %rsi
callq 0x14b75
xorl %eax, %eax
testb %al, %al
je 0x1e893
movq 0x18(%r12), %r12
testq %r12, %r12
jne 0x1e81d
movq %rbx, %rdi
movq (%rsp), %rsi
callq 0x14b75
movq %r14, %rdi
callq 0x1030
jmp 0x1e89a
movq $-0x1, %r15
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/vertexQueue.c
// Function: popFromVertexQueue
struct Vertex* popFromVertexQueue(struct ShallowGraph* queue, struct ShallowGraphPool* sgp) {
	struct VertexList* e = popEdge(queue);
	if (e != NULL) {
		struct Vertex* v = e->endPoint;
		dumpVertexList(sgp->listPool, e);
		return v;
	} else {
		return NULL;
	}
}

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

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %rbx
movq %rdx, %r12
movq %rsi, 0x10(%rsp)
movq %rdi, %r15
movq 0x10(%rdx), %rdi
callq 0x145b2
movq %rax, 0x8(%rsp)
movq %rbx, %rdi
callq 0x14aae
movq %rax, %r14
movq %r15, %rdi
callq 0x7c22
movslq %eax, %rbp
leaq (,%rbp,8), %rdi
callq 0x1190
movq %rax, %r13
movq 0x8(%r15), %rax
testq %rax, %rax
je 0x1e98b
movq %r13, %rcx
movq 0x18(%rax), %rdx
movq (%rdx), %rdx
movq %rdx, (%rcx)
movq 0x8(%rax), %rax
addq $0x8, %rcx
testq %rax, %rax
jne 0x1e974
leaq 0xd5(%rip), %rcx        # 0x1ea67
movl $0x8, %edx
movq %r13, %rdi
movq %rbp, %rsi
callq 0x1080
movq 0x10(%rbx), %rdi
callq 0x1432b
movq (%r15), %rcx
movq %rcx, (%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0x88b9
testl %ebp, %ebp
jle 0x1e9e7
xorl %r15d, %r15d
movq 0x10(%rbx), %rdi
callq 0x1432b
movq (%r13,%r15,8), %rcx
movq %rcx, (%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0x88b9
incq %r15
cmpq %r15, %rbp
jne 0x1e9c3
movq %r14, %rdi
movq %rbx, %rsi
callq 0x87fa
movq 0x8(%rsp), %rbp
movq %rbp, %rdi
movq %rax, %rsi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x1af0f
movq 0x10(%rsp), %r15
movq %r15, %rdi
movq %rbp, %rsi
movl $0x1, %edx
xorl %ecx, %ecx
xorl %r8d, %r8d
movq %r15, %r9
pushq %r12
pushq $0x0
callq 0x1afe3
addq $0x10, %rsp
movq %r15, %rdi
movq %r14, %rsi
callq 0x1ae44
movl %eax, %edi
callq 0xdde3
movq %rax, %r15
movq %rbx, %rdi
movq %r14, %rsi
callq 0x14b75
movq %r13, %rdi
callq 0x1030
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/weisfeilerLehman.c
// Function: weisfeilerLehmanRelabel
struct Graph* weisfeilerLehmanRelabel(struct Graph* g, struct Vertex* wlLabels, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	struct Graph* h = cloneGraph(g, gp);
	int v;

	for (v=0; v<g->n; ++v) {
		h->vertices[v]->label = getWLLabel(g->vertices[v], wlLabels, gp, sgp);
		h->vertices[v]->isStringMaster = 1;
	}
	// fprintf(stderr, "\n\n\n");
	// printStringsInSearchTree(wlLabels, stderr, sgp);
	return h;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
movq %rdx, %rsi
callq 0x7f7e
movq %rax, %r13
cmpl $0x0, (%r12)
jle 0x1ead6
xorl %ebp, %ebp
movq 0x10(%r12), %rax
movq (%rax,%rbp,8), %rdi
movq %r15, %rsi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x1e918
movq 0x10(%r13), %rcx
movq (%rcx,%rbp,8), %rdx
movq %rax, (%rdx)
movq (%rcx,%rbp,8), %rax
movl $0x1, 0x24(%rax)
incq %rbp
movslq (%r12), %rax
cmpq %rax, %rbp
jl 0x1ea9d
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/wilsonsAlgorithm.c
// Function: initIntegerArrayStack
struct IntegerArrayStack* initIntegerArrayStack(int capacity) {
	struct IntegerArrayStack* ias = malloc(sizeof(struct IntegerArrayStack));
	ias->stackData = malloc(capacity * sizeof(int));
	ias->top = -1;
	ias->capacity = capacity;
	return ias;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %edi, %ebx
movl $0x10, %edi
callq 0x1190
movq %rax, %r14
movslq %ebx, %rbx
leaq (,%rbx,4), %rdi
callq 0x1190
movq %rax, (%r14)
movl $0xffffffff, 0x8(%r14)  # imm = 0xFFFFFFFF
movl %ebx, 0xc(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/wilsonsAlgorithm.c
// Function: ias_shuffleArray
void ias_shuffleArray(struct IntegerArrayStack* ias) {
	int i;
	for (i = ias->capacity - 1; i > 0; i--)
	{
		int index = rand() % (i + 1);
		// Simple swap
		int a = ias->stackData[index];
		ias->stackData[index] = ias->stackData[i];
		ias->stackData[i] = a;
	}
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movslq 0xc(%rdi), %r14
cmpq $0x2, %r14
jl 0x1ebad
movq %rdi, %rbx
leaq -0x1(%r14), %r15
callq 0x1250
cltd
idivl %r14d
movq (%rbx), %rax
movslq %edx, %rcx
movl (%rax,%rcx,4), %edx
movl -0x4(%rax,%r14,4), %esi
movl %esi, (%rax,%rcx,4)
movl %edx, -0x4(%rax,%r14,4)
cmpq $0x2, %r14
movq %r15, %r14
jg 0x1eb81
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/wilsonsAlgorithm.c
// Function: randomSpanningTreeAsShallowGraph
struct ShallowGraph* randomSpanningTreeAsShallowGraph(struct Graph* g, struct ShallowGraphPool* sgp) {
	if (g->m == 0) {
		return getShallowGraph(sgp);
	} else {
		return _randomSpanningTreeAsShallowGraph(g, sgp);
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rsi, %r13
cmpl $0x0, 0x4(%rdi)
je 0x1ed15
movq %rdi, %r14
movslq (%rdi), %rbx
leaq (,%rbx,8), %rdi
callq 0x1190
movq %rax, (%rsp)
movq %rbx, %rdi
callq 0x1190
movq %rax, %r12
movq %r13, %rdi
callq 0x14aae
movq %rax, 0x8(%rsp)
movslq (%r14), %r15
movl $0x10, %edi
callq 0x1190
movq %rax, %rbp
leaq (,%r15,4), %rdi
callq 0x1190
movq %rax, %rbx
movq %rax, (%rbp)
movl $0xffffffff, 0x8(%rbp)  # imm = 0xFFFFFFFF
movl %r15d, 0xc(%rbp)
testq %r15, %r15
jle 0x1ecf7
movq %r13, 0x10(%rsp)
leaq (,%r15,8), %rdx
xorl %r13d, %r13d
movq (%rsp), %rdi
xorl %esi, %esi
callq 0x10d0
movq %r12, %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x10d0
movl %r13d, (%rbx,%r13,4)
incq %r13
cmpq %r13, %r15
jne 0x1ecdf
decl %r13d
movl %r13d, 0x8(%rbp)
movq 0x10(%rsp), %r13
movq %rbp, %rdi
callq 0x1eb6f
movslq 0x8(%rbp), %rax
cmpq $-0x1, %rax
je 0x1ed2b
leal -0x1(%rax), %ecx
movl %ecx, 0x8(%rbp)
movslq (%rbx,%rax,4), %rax
jmp 0x1ed32
movq %r13, %rdi
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x14aae
movq $-0x1, %rax
movq (%rsp), %rbx
movq 0x8(%rsp), %r15
movb $0x1, (%r12,%rax)
movq 0x10(%r13), %r9
movq %r14, %rdi
movq %rbp, %rsi
movq %rbx, %rdx
movq %r12, %rcx
movq %r15, %r8
callq 0x1edaf
testb %al, %al
je 0x1ed40
movq %rbp, %rdi
callq 0x1eb55
movq %rbx, %rdi
callq 0x1030
movq %r12, %rdi
callq 0x1030
movq %r15, %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/executables/outerplanaritytest.c
// Function: addSpiderWebEdges
void addSpiderWebEdges(struct BBTree* bbTree, struct ShallowGraphPool* sgp) {
    printf(", \"spiderweb\": {");
    if (bbTree->tree->n > 0) {
        computeDistanceToCenter(bbTree->tree, sgp);
        char first = 1;
        for (int v=0; v<bbTree->tree->n; ++v) {
            if (first) {
                first = 0;
            } else {
                printf(", ");
            }
            printf("\"%d\": %d", bbTree->originalIDs[v], bbTree->tree->vertices[v]->lowPoint);
        }
    }
    putc('}', stdout);
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
leaq 0x22ca(%rip), %rdi      # 0x21674
xorl %eax, %eax
callq 0x10b0
movq (%rbx), %rdi
cmpl $0x0, (%rdi)
jle 0x1f41a
movq %r14, %rsi
callq 0x1d50a
movq (%rbx), %rax
cmpl $0x0, (%rax)
jle 0x1f41a
xorl %eax, %eax
leaq 0x101b(%rip), %r14      # 0x203ed
leaq 0x22ac(%rip), %r15      # 0x21685
xorl %r12d, %r12d
testb $0x1, %al
je 0x1f3ea
movq %r14, %rdi
xorl %eax, %eax
callq 0x10b0
movq (%rbx), %rax
movq 0x18(%rbx), %rcx
movl (%rcx,%r12,4), %esi
movq 0x10(%rax), %rax
movq (%rax,%r12,8), %rax
movl 0x20(%rax), %edx
movq %r15, %rdi
xorl %eax, %eax
callq 0x10b0
incq %r12
movq (%rbx), %rax
movslq (%rax), %rcx
movb $0x1, %al
cmpq %rcx, %r12
jl 0x1f3dc
movq 0xdba7(%rip), %rax      # 0x2cfc8
movq (%rax), %rsi
movl $0x7d, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1130
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/executables/outerplanaritytest.c
// Function: printInterestingEdges
char printInterestingEdges(struct Vertex* lastInteresting, struct Vertex* v, char notFirst, int* originalIDs, char printAll) {
    v->visited = 1;
    if (v->lowPoint) {
        if (lastInteresting) {
            char isNeighbor = 0;
            for (struct VertexList* e=v->neighborhood; e!=NULL; e=e->next) {
                if (e->endPoint == lastInteresting) {
                    isNeighbor = 1;
                    break;
                }
            }
            if (printAll || !isNeighbor) {
                if (notFirst) {
                    printf(", ");
                }
                printf("[%d, %d]", originalIDs[lastInteresting->number], originalIDs[v->number]);
                notFirst = 1;
            }
        }
    }
    for (struct VertexList* e=v->neighborhood; e!=NULL; e=e->next) {
        if (e->endPoint->visited == 0) {
            if (v->lowPoint) {
                notFirst = printInterestingEdges(v, e->endPoint, notFirst, originalIDs, printAll);
            } else {
                notFirst = printInterestingEdges(lastInteresting, e->endPoint, notFirst, originalIDs, printAll);
            }
        }
    }
    return notFirst;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %r8d, %ebp
movq %rcx, %rbx
movl %edx, %eax
movq %rsi, %r14
movq %rdi, %r15
movl $0x1, 0x1c(%rsi)
testq %rdi, %rdi
je 0x1f4b4
cmpl $0x0, 0x20(%r14)
je 0x1f4b4
movq %r14, %rcx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
je 0x1f474
cmpq %r15, 0x18(%rcx)
jne 0x1f465
testq %rcx, %rcx
setne %cl
testb %bpl, %bpl
sete %dl
testb %cl, %dl
jne 0x1f4b4
testb %al, %al
je 0x1f496
leaq 0xf5e(%rip), %rdi       # 0x203ed
xorl %eax, %eax
callq 0x10b0
movslq 0x18(%r15), %rax
movl (%rbx,%rax,4), %esi
movslq 0x18(%r14), %rax
movl (%rbx,%rax,4), %edx
leaq 0x21e3(%rip), %rdi      # 0x2168e
xorl %eax, %eax
callq 0x10b0
movb $0x1, %al
movq 0x8(%r14), %r12
testq %r12, %r12
je 0x1f4f0
movsbl %bpl, %ebp
movq 0x18(%r12), %rsi
cmpl $0x0, 0x1c(%rsi)
jne 0x1f4e6
cmpl $0x0, 0x20(%r14)
movq %r14, %rdi
cmoveq %r15, %rdi
movsbl %al, %edx
movq %rbx, %rcx
movl %ebp, %r8d
callq 0x1f439
movq 0x8(%r12), %r12
testq %r12, %r12
jne 0x1f4c1
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/executables/outerplanaritytest.c
// Function: addShortcutEdges
void addShortcutEdges(struct BBTree* bbTree, char printAll) {
    int root = 0;
    /* mark interesting vertices, keep the last leaf or join as root */
    for (int v=0; v<bbTree->tree->n; ++v) {
        bbTree->tree->vertices[v]->visited = 0;
        if (degree(bbTree->tree->vertices[v]) != 2) {
            bbTree->tree->vertices[v]->lowPoint = 1;
            root = v;
        } else {
            bbTree->tree->vertices[v]->lowPoint = 0;
        } 
    }
    if (bbTree->blocks) {
        for (int v=0; v<bbTree->blocks->n; ++v) {
            bbTree->blocks->vertices[v]->lowPoint = 2;
        }
    }

    printf(", \"shortcutEdges\": [");
    printInterestingEdges(NULL, bbTree->tree->vertices[root], 0, bbTree->originalIDs, printAll);
    printf("]");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
movq (%rdi), %rax
xorl %r15d, %r15d
cmpl $0x0, (%rax)
jle 0x1f55c
xorl %r12d, %r12d
movq 0x10(%rax), %rax
movq (%rax,%r12,8), %rdi
movl $0x0, 0x1c(%rdi)
callq 0x7c22
movq (%r14), %rcx
movq 0x10(%rcx), %rcx
movq (%rcx,%r12,8), %rcx
cmpl $0x2, %eax
jne 0x1f541
movl $0x0, 0x20(%rcx)
jmp 0x1f54b
movl $0x1, 0x20(%rcx)
movl %r12d, %r15d
incq %r12
movq (%r14), %rax
movslq (%rax), %rcx
cmpq %rcx, %r12
jl 0x1f514
movslq %r15d, %r15
movq 0x8(%r14), %rcx
testq %rcx, %rcx
je 0x1f586
movslq (%rcx), %rax
testq %rax, %rax
jle 0x1f586
movq 0x10(%rcx), %rcx
xorl %edx, %edx
movq (%rcx,%rdx,8), %rsi
movl $0x2, 0x20(%rsi)
incq %rdx
cmpq %rdx, %rax
jne 0x1f573
leaq 0x210a(%rip), %rdi      # 0x21697
xorl %eax, %eax
callq 0x10b0
movq (%r14), %rax
movq 0x18(%r14), %rcx
movq 0x10(%rax), %rax
movq (%rax,%r15,8), %rsi
movsbl %bl, %r8d
xorl %edi, %edi
xorl %edx, %edx
callq 0x1f439
movl $0x5d, %edi
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/executables/outerplanaritytest.c
// Function: printBBTreeEdges
void printBBTreeEdges(struct BBTree* bbTree) {
    int root = 0;
    /* mark all vertices as interesting */
    for (int v=0; v<bbTree->tree->n; ++v) {
        bbTree->tree->vertices[v]->visited = 0;
        bbTree->tree->vertices[v]->lowPoint = 1;
    }

    printf(", \"CATree\": [");
    printInterestingEdges(NULL, bbTree->tree->vertices[root], 0, bbTree->originalIDs, 1);
    printf("]");
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rdi), %rcx
movslq (%rcx), %rax
testq %rax, %rax
jle 0x1f5f4
movq 0x10(%rcx), %rcx
xorl %edx, %edx
movabsq $0x100000000, %rsi      # imm = 0x100000000
movq (%rcx,%rdx,8), %rdi
movq %rsi, 0x1c(%rdi)
incq %rdx
cmpq %rdx, %rax
jne 0x1f5e4
leaq 0x20b1(%rip), %rdi      # 0x216ac
xorl %eax, %eax
callq 0x10b0
movq (%rbx), %rax
movq 0x18(%rbx), %rcx
movq 0x10(%rax), %rax
movq (%rax), %rsi
xorl %edi, %edi
xorl %edx, %edx
movl $0x1, %r8d
callq 0x1f439
movl $0x5d, %edi
popq %rbx
jmp 0x1040
// File: /workspace/github_c_makefile_star2_O1/ataradov[P]edbg/edbg.c
// Function: warning
void warning(char *fmt, ...)
{
  va_list args;

  va_start(args, fmt);
  fprintf(stderr, "Warning: ");
  vfprintf(stderr, fmt, args);
  fprintf(stderr, "\n");
  va_end(args);
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0xd0, %rsp
movq %rdi, %rbx
leaq 0x20(%rsp), %rdi
movq %rsi, 0x8(%rdi)
movq %rdx, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %r8, 0x20(%rdi)
movq %r9, 0x28(%rdi)
testb %al, %al
je 0x6353
movaps %xmm0, 0x50(%rsp)
movaps %xmm1, 0x60(%rsp)
movaps %xmm2, 0x70(%rsp)
movaps %xmm3, 0x80(%rsp)
movaps %xmm4, 0x90(%rsp)
movaps %xmm5, 0xa0(%rsp)
movaps %xmm6, 0xb0(%rsp)
movaps %xmm7, 0xc0(%rsp)
movq %rsp, %r14
movq %rdi, 0x10(%r14)
leaq 0xf0(%rsp), %rax
movq %rax, 0x8(%r14)
movabsq $0x3000000008, %rax     # imm = 0x3000000008
movq %rax, (%r14)
movq 0x14c76(%rip), %r15     # 0x1aff0
movq (%r15), %rcx
leaq 0xa20c(%rip), %rdi      # 0x10590
pushq $0x9
popq %rsi
pushq $0x1
popq %rdx
callq 0x6280
movq (%r15), %rdi
movq %rbx, %rsi
movq %r14, %rdx
callq 0x6230
movq (%r15), %rsi
pushq $0xa
popq %rdi
callq 0x6130
addq $0xd0, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/ataradov[P]edbg/dap.c
// Function: dap_led
void dap_led(int index, int state)
{
  uint8_t buf[3];

  buf[0] = ID_DAP_LED;
  buf[1] = index;
  buf[2] = state;
  dbg_dap_cmd(buf, sizeof(buf), 3);

  check(DAP_OK == buf[0], "DAP_LED failed");
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
leaq 0xd(%rsp), %rbx
movb $0x1, (%rbx)
movb %dil, 0x1(%rbx)
movb %sil, 0x2(%rbx)
movq %rbx, %rdi
movl $0x3, %esi
movl $0x3, %edx
callq 0xf4a0
xorl %edi, %edi
cmpb $0x0, (%rbx)
sete %dil
leaq 0x9adf(%rip), %rsi      # 0x10020
xorl %eax, %eax
callq 0x7bb4
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/ataradov[P]edbg/dap.c
// Function: dap_connect
void dap_connect(int interf)
{
  uint8_t buf[2];
  int cap = (DAP_INTERFACE_SWD == interf) ? DAP_CAP_SWD : DAP_CAP_JTAG;

  buf[0] = ID_DAP_CONNECT;
  buf[1] = cap;
  dbg_dap_cmd(buf, sizeof(buf), 2);

  check(buf[0] == cap, "DAP_CONNECT failed");

  dap_interface = interf;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x10, %rsp
movl %edi, %ebx
xorl %ebp, %ebp
cmpl $0x1, %edi
setne %bpl
incl %ebp
leaq 0xe(%rsp), %r14
movb $0x2, (%r14)
movb %bpl, 0x1(%r14)
movq %r14, %rdi
movl $0x2, %esi
movl $0x2, %edx
callq 0xf4a0
movzbl (%r14), %eax
xorl %edi, %edi
cmpl %eax, %ebp
sete %dil
leaq 0x9a9a(%rip), %rsi      # 0x1002f
xorl %eax, %eax
callq 0x7bb4
movl %ebx, 0x15bae(%rip)     # 0x1c150
addq $0x10, %rsp
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ataradov[P]edbg/dap.c
// Function: dap_swj_clock
void dap_swj_clock(uint32_t clock)
{
  uint8_t buf[5];

  buf[0] = ID_DAP_SWJ_CLOCK;
  buf[1] = clock & 0xff;
  buf[2] = (clock >> 8) & 0xff;
  buf[3] = (clock >> 16) & 0xff;
  buf[4] = (clock >> 24) & 0xff;
  dbg_dap_cmd(buf, sizeof(buf), 5);

  check(DAP_OK == buf[0], "SWJ_CLOCK failed");
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl %edi, %eax
leaq 0xb(%rsp), %rbx
movb $0x11, (%rbx)
movb %al, 0x1(%rbx)
movb %ah, 0xd(%rsp)
movl %edi, %ecx
shrl $0x10, %ecx
movb %cl, 0x3(%rbx)
shrl $0x18, %eax
movb %al, 0x4(%rbx)
movq %rbx, %rdi
movl $0x5, %esi
movl $0x5, %edx
callq 0xf4a0
xorl %edi, %edi
cmpb $0x0, (%rbx)
sete %dil
leaq 0x9a2d(%rip), %rsi      # 0x10042
xorl %eax, %eax
callq 0x7bb4
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/ataradov[P]edbg/dap.c
// Function: dap_transfer_configure
void dap_transfer_configure(uint8_t idle, uint16_t retry, uint16_t match_retry)
{
  uint8_t buf[6];

  buf[0] = ID_DAP_TRANSFER_CONFIGURE;
  buf[1] = idle;
  buf[2] = retry & 0xff;
  buf[3] = (retry >> 8) & 0xff;
  buf[4] = match_retry & 0xff;
  buf[5] = (match_retry >> 8) & 0xff;
  dbg_dap_cmd(buf, sizeof(buf), 6);

  check(DAP_OK == buf[0], "TRANSFER_CONFIGURE failed");
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl %esi, %eax
leaq 0xa(%rsp), %rbx
movb $0x4, (%rbx)
movb %dil, 0x1(%rbx)
movb %al, 0x2(%rbx)
movb %ah, 0xd(%rsp)
movb %dl, 0x4(%rbx)
movb %dh, 0xf(%rsp)
movq %rbx, %rdi
movl $0x6, %esi
movl $0x6, %edx
callq 0xf4a0
xorl %edi, %edi
cmpb $0x0, (%rbx)
sete %dil
leaq 0x99ee(%rip), %rsi      # 0x10053
xorl %eax, %eax
callq 0x7bb4
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/ataradov[P]edbg/dap.c
// Function: dap_swd_configure
void dap_swd_configure(int cfg)
{
  uint8_t buf[2];

  buf[0] = ID_DAP_SWD_CONFIGURE;
  buf[1] = cfg;
  dbg_dap_cmd(buf, sizeof(buf), 2);

  check(DAP_OK == buf[0], "SWD_CONFIGURE failed");
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
leaq 0xe(%rsp), %rbx
movb $0x13, (%rbx)
movb %dil, 0x1(%rbx)
movq %rbx, %rdi
movl $0x2, %esi
movl $0x2, %edx
callq 0xf4a0
xorl %edi, %edi
cmpb $0x0, (%rbx)
sete %dil
leaq 0x99c8(%rip), %rsi      # 0x1006d
xorl %eax, %eax
callq 0x7bb4
addq $0x10, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/ataradov[P]edbg/dap.c
// Function: dap_jtag_configure
void dap_jtag_configure(int count, int *ir_len)
{
  uint8_t buf[32];

  buf[0] = ID_DAP_JTAG_CONFIGURE;
  buf[1] = count;
  for (int i = 0; i < count; i++)
    buf[2+i] = ir_len[i];
  dbg_dap_cmd(buf, sizeof(buf), 2 + count);

  check(DAP_OK == buf[0], "JTAG_CONFIGURE failed");
}

// Assembly:
pushq %rbx
subq $0x20, %rsp
movl %edi, %edx
movb $0x15, (%rsp)
movb %dl, 0x1(%rsp)
testl %edi, %edi
jle 0x66da
movl %edx, %eax
xorl %ecx, %ecx
movb (%rsi,%rcx,4), %dil
movb %dil, 0x2(%rsp,%rcx)
incq %rcx
cmpq %rcx, %rax
jne 0x66c9
addl $0x2, %edx
movq %rsp, %rbx
movq %rbx, %rdi
movl $0x20, %esi
callq 0xf4a0
xorl %edi, %edi
cmpb $0x0, (%rbx)
sete %dil
leaq 0x9985(%rip), %rsi      # 0x10082
xorl %eax, %eax
callq 0x7bb4
addq $0x20, %rsp
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/ataradov[P]edbg/dap.c
// Function: dap_info
int dap_info(int info, uint8_t *data, int size)
{
  uint8_t buf[256];
  int rsize;

  buf[0] = ID_DAP_INFO;
  buf[1] = info;
  dbg_dap_cmd(buf, sizeof(buf), 2);

  rsize = (size < buf[0]) ? size : buf[0];
  memcpy(data, &buf[1], rsize);

  if (rsize < size)
    data[rsize] = 0;

  return rsize;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movl %edx, %r15d
movq %rsi, %rbx
leaq 0x1(%rsp), %r12
movb $0x0, -0x1(%r12)
movb %dil, (%r12)
movq %rsp, %r14
movq %r14, %rdi
movl $0x100, %esi            # imm = 0x100
movl $0x2, %edx
callq 0xf4a0
movzbl (%r14), %r13d
cmpl %r15d, %r13d
movl %r15d, %ebp
cmovll %r13d, %ebp
movslq %ebp, %r14
movq %rbx, %rdi
movq %r12, %rsi
movq %r14, %rdx
callq 0x6180
cmpl %r15d, %r13d
jge 0x6775
movb $0x0, (%rbx,%r14)
movl %ebp, %eax
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/ataradov[P]edbg/dap.c
// Function: dap_read_idcode
uint32_t dap_read_idcode(void)
{
  if (DAP_INTERFACE_SWD == dap_interface)
  {
    dap_read_idcode_req();
    dap_transfer();
    return dap_response[0];
  }
  else if (DAP_INTERFACE_JTAG == dap_interface)
  {
    uint8_t buf[16];

    buf[0] = ID_DAP_JTAG_IDCODE;
    buf[1] = dap_jtag_index;

    dbg_dap_cmd(buf, sizeof(buf), 2);
    check(DAP_OK == buf[0], "JTAG_IDCODE failed");

    return *((uint32_t *)&buf[1]);
  }

  return 0;
}

// Assembly:
pushq %rbx
subq $0x10, %rsp
movl 0x157a7(%rip), %ecx     # 0x1c150
cmpl $0x2, %ecx
je 0x69d5
xorl %eax, %eax
cmpl $0x1, %ecx
jne 0x6a10
movl $0x3, %edi
movl $0x2, %esi
xorl %edx, %edx
xorl %ecx, %ecx
callq 0x6a16
callq 0x6a6f
movl 0x4602d(%rip), %eax     # 0x4ca00
jmp 0x6a10
movq %rsp, %rbx
movb $0x16, (%rbx)
movb 0x15773(%rip), %al      # 0x1c154
movb %al, 0x1(%rbx)
movq %rbx, %rdi
movl $0x10, %esi
movl $0x2, %edx
callq 0xf4a0
xorl %edi, %edi
cmpb $0x0, (%rbx)
sete %dil
leaq 0x9811(%rip), %rsi      # 0x10217
xorl %eax, %eax
callq 0x7bb4
movl 0x1(%rbx), %eax
addq $0x10, %rsp
popq %rbx
retq