LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/listCycles.c
// Function: listCycles
struct ShallowGraph* listCycles(struct Graph *g, struct ShallowGraphPool *sgp) {
	int i;
	struct ShallowGraph* result = NULL;


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


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


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

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

			result = addComponent(result, newCycle);

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

	return result;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq $0x0, 0x18(%rsp)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
movq 0x30(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x11884
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x24(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x11872
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x24(%rsp), %rcx
movq (%rax,%rcx,8), %rax
cmpq $0x0, 0x8(%rax)
je 0x11872
movq 0x28(%rsp), %rdi
callq 0x1fe70
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x24(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movl $0x1, 0x1c(%rax)
movq 0x30(%rsp), %rdi
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x24(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x24(%rsp), %rcx
movq (%rax,%rcx,8), %rdx
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x24(%rsp), %rcx
movq (%rax,%rcx,8), %rcx
movl 0x24(%rsp), %r8d
movq 0x10(%rsp), %r9
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
callq 0x11d90
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0xbd60
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x1ff70
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x24(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movl $0x0, 0x1c(%rax)
jmp 0x11874
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x1176f
movq 0x18(%rsp), %rax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/listCycles.c
// Function: _cleanUpLowPoint
void __cleanUpLowPoint(struct Vertex*v) {
	struct VertexList* idx;
	v->lowPoint = 0;
	for (idx=v->neighborhood; idx; idx=idx->next) {
		if (idx->endPoint->lowPoint != 0) {
			__cleanUpLowPoint(idx->endPoint);
		}
	}
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movl $0x0, 0x20(%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x11c1a
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
cmpl $0x0, 0x20(%rax)
je 0x11c08
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x11bc0
jmp 0x11c0a
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x11be3
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/listCycles.c
// Function: _DFS
char __DFS(struct Vertex* v, struct Vertex* parent, struct Vertex* target, int allowance) {
	struct VertexList* idx;
	char flag = 0;

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

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

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

	return flag;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movl %ecx, 0x14(%rsp)
movb $0x0, 0x7(%rsp)
movq 0x28(%rsp), %rax
movl 0x18(%rax), %eax
movq 0x18(%rsp), %rcx
cmpl 0x18(%rcx), %eax
jne 0x11cb8
movb $0x1, 0x37(%rsp)
jmp 0x11d7c
movq 0x28(%rsp), %rax
movl $0x1, 0x28(%rax)
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x11d74
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movl 0x18(%rax), %eax
cmpl 0x14(%rsp), %eax
jl 0x11d5f
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movl 0x18(%rax), %eax
movq 0x20(%rsp), %rcx
cmpl 0x18(%rcx), %eax
je 0x11d5f
cmpb $0x0, 0x7(%rsp)
jne 0x11d5d
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movl 0x18(%rax), %eax
movq 0x18(%rsp), %rcx
cmpl 0x18(%rcx), %eax
jne 0x11d2a
movb $0x1, 0x7(%rsp)
jmp 0x11d5b
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
cmpl $0x0, 0x28(%rax)
jne 0x11d59
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x28(%rsp), %rsi
movq 0x18(%rsp), %rdx
movl 0x14(%rsp), %ecx
callq 0x11c80
movb %al, 0x7(%rsp)
jmp 0x11d5b
jmp 0x11d5d
jmp 0x11d5f
jmp 0x11d61
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x11cd2
movb 0x7(%rsp), %al
movb %al, 0x37(%rsp)
movb 0x37(%rsp), %al
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/listCycles.c
// Function: listCyclesOfLength
struct ShallowGraph* listCyclesOfLength(struct Graph *g, int cycleLength, struct ShallowGraphPool *sgp) {
	struct ShallowGraph* result = listCycles(g, sgp);

	if (result) {

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

	return result;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x40(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x11750
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x125cf
movq 0x28(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x20(%rsp), %rax
je 0x12549
movq 0x18(%rsp), %rax
movl 0x10(%rax), %eax
cmpl 0x3c(%rsp), %eax
je 0x12539
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rcx
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rcx
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x20(%rax)
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x1ff70
jmp 0x12547
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
jmp 0x124ca
movq 0x20(%rsp), %rax
movl 0x10(%rax), %eax
cmpl 0x3c(%rsp), %eax
je 0x125c5
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rax
cmpq 0x20(%rsp), %rax
jne 0x1257c
movq $0x0, 0x20(%rsp)
jmp 0x125b6
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rcx
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rcx
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x20(%rax)
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x1ff70
movq 0x20(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/listSpanningTrees.c
// Function: _visit
void __visit(struct Vertex* v, int component, int* components) {
	struct VertexList* e;

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

	components[v->number] = component;

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

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
movslq 0x18(%rcx), %rcx
cmpl $-0x1, (%rax,%rcx,4)
je 0x12608
jmp 0x1265a
movl 0x1c(%rsp), %edx
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
movslq 0x18(%rcx), %rcx
movl %edx, (%rax,%rcx,4)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x1265a
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
movl 0x1c(%rsp), %esi
movq 0x10(%rsp), %rdx
callq 0x125e0
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x1262b
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/listSpanningTrees.c
// Function: _selectB
struct ShallowGraph* __selectB(struct Graph* partialTree, struct ShallowGraph* rest, int* components, int n, struct ShallowGraphPool* sgp) {
	struct ShallowGraph* B = getShallowGraph(sgp);
	struct VertexList* e;

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

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

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

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

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movl %ecx, 0x3c(%rsp)
movq %r8, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0x1fe70
movq %rax, 0x28(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x3c(%rsp), %eax
jge 0x126bb
movq 0x40(%rsp), %rax
movslq 0x1c(%rsp), %rcx
movl $0xffffffff, (%rax,%rcx,4) # imm = 0xFFFFFFFF
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x12693
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
cmpl 0x3c(%rsp), %eax
jge 0x126fa
movq 0x50(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movl 0x18(%rsp), %esi
movq 0x40(%rsp), %rdx
callq 0x125e0
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x126c3
movq 0x48(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x1278c
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movl 0x18(%rax), %eax
movl %eax, 0x14(%rsp)
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rax
movl 0x18(%rax), %eax
movl %eax, 0x10(%rsp)
movq 0x40(%rsp), %rax
movslq 0x14(%rsp), %rcx
cmpl $-0x1, (%rax,%rcx,4)
je 0x12777
movq 0x40(%rsp), %rax
movslq 0x10(%rsp), %rcx
cmpl $-0x1, (%rax,%rcx,4)
je 0x12777
movq 0x40(%rsp), %rax
movslq 0x14(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movq 0x40(%rsp), %rcx
movslq 0x10(%rsp), %rdx
cmpl (%rcx,%rdx,4), %eax
jne 0x12777
movq 0x20(%rsp), %rax
movl $0x1, 0x24(%rax)
jmp 0x12779
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x12707
movq 0x30(%rsp), %rdi
callq 0x1fe70
movq %rax, %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x48(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x12819
movq 0x20(%rsp), %rax
cmpl $0x1, 0x24(%rax)
jne 0x127e5
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x48(%rsp), %rdi
callq 0xbef0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0xb610
jmp 0x12808
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, (%rsp)
movq 0x48(%rsp), %rdi
callq 0xbef0
movq (%rsp), %rdi
movq %rax, %rsi
callq 0xb610
jmp 0x1280a
movq 0x48(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x127af
movq 0x28(%rsp), %rax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/listSpanningTrees.c
// Function: _getGraphAndNonGraphEdges
struct ShallowGraph* __getGraphAndNonGraphEdges(struct Graph* graph, struct ShallowGraph* list, struct ShallowGraphPool* sgp) {
	struct VertexList* e;
	struct ShallowGraph* graphEdges = getShallowGraph(sgp);
	struct ShallowGraph* nonGraphEdges = getShallowGraph(sgp);

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

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

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

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0x1fe70
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
callq 0x1fe70
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x128b3
movq 0x40(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
movl 0x18(%rax), %esi
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rax
movl 0x18(%rax), %edx
callq 0xb490
movsbl %al, %ecx
movq 0x28(%rsp), %rax
movl %ecx, 0x24(%rax)
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x28(%rsp)
jmp 0x1286e
movq 0x38(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x12928
movq 0x28(%rsp), %rax
cmpl $0x1, 0x24(%rax)
jne 0x128f6
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rdi
callq 0xbef0
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0xb610
jmp 0x12917
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
callq 0xbef0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0xb610
jmp 0x12919
movq 0x38(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x28(%rsp)
jmp 0x128c0
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x1ff70
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x20(%rax)
movq 0x20(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/listSpanningTrees.c
// Function: _getNonTreeBridges
struct ShallowGraph* __getNonTreeBridges(struct Graph* graph, struct Graph* partialTree, struct ShallowGraphPool* sgp) {
	struct ShallowGraph* tmp = getShallowGraph(sgp);
	struct ShallowGraph* biconnectedComponents = listBiconnectedComponents(graph, sgp);
	struct ShallowGraph* idx;
	struct ShallowGraph* nonTreeBridges;

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

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

	return nonTreeBridges;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0x1fe70
movq %rax, 0x28(%rsp)
movq 0x40(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x10700
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x129e6
movq 0x18(%rsp), %rax
cmpl $0x1, 0x10(%rax)
jne 0x129d4
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0xbef0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0xb610
jmp 0x129d6
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
jmp 0x129a0
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x20000
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
callq 0x12830
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq $0x0, 0x18(%rax)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x1ff70
movq 0x10(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/listSpanningTrees.c
// Function: listSpanningTrees
struct ShallowGraph* listSpanningTrees(struct Graph* original, struct ShallowGraphPool* sgp, struct GraphPool* gp) {
	
	struct Graph* graph = cloneGraph(original, gp);
	struct Graph* partialTree = emptyGraph(original, gp);
	struct ShallowGraph* result = NULL;
	int* components = malloc(sizeof(int) * original->n);
	struct ShallowGraph* idx;

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

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

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

	return result;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq 0x50(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0xacb0
movq %rax, 0x38(%rsp)
movq 0x50(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0xb7c0
movq %rax, 0x30(%rsp)
movq $0x0, 0x28(%rsp)
movq 0x50(%rsp), %rax
movslq (%rax), %rdi
shlq $0x2, %rdi
callq 0x1170
movq %rax, 0x20(%rsp)
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x10700
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x12df9
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
cmpl $0x1, 0x10(%rax)
jne 0x12de7
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movl 0x18(%rax), %edi
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movl 0x18(%rax), %esi
movq 0x8(%rsp), %rax
movq (%rax), %rdx
movq 0x30(%rsp), %rcx
movq 0x40(%rsp), %r8
callq 0xb670
jmp 0x12de9
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
jmp 0x12d98
movq 0x48(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x20000
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x20(%rsp), %rcx
movq 0x38(%rsp), %rax
movl (%rax), %r8d
movq 0x48(%rsp), %r9
movq 0x40(%rsp), %rax
xorl %edi, %edi
movq %rax, (%rsp)
callq 0x12a50
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq 0x20(%rax), %rax
movq $0x0, 0x18(%rax)
movq 0x28(%rsp), %rax
movq $0x0, 0x20(%rax)
movq 0x28(%rsp), %rdi
movq 0x50(%rsp), %rsi
callq 0xbc00
movq 0x20(%rsp), %rdi
callq 0x1030
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x1fb30
movq 0x40(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x1fb30
movq 0x28(%rsp), %rax
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/listSpanningTrees.c
// Function: countSpanningTrees
long int countSpanningTrees(struct Graph* original, long int maxBound, struct ShallowGraphPool* sgp, struct GraphPool* gp) {

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

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

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

	return result;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq 0x60(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0xacb0
movq %rax, 0x40(%rsp)
movq 0x60(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0xb7c0
movq %rax, 0x38(%rsp)
movq 0x60(%rsp), %rax
movslq (%rax), %rdi
shlq $0x2, %rdi
callq 0x1170
movq %rax, 0x28(%rsp)
movq 0x60(%rsp), %rdi
movq 0x50(%rsp), %rsi
callq 0x10700
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x13775
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
cmpl $0x1, 0x10(%rax)
jne 0x13763
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movl 0x18(%rax), %edi
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movl 0x18(%rax), %esi
movq 0x10(%rsp), %rax
movq (%rax), %rdx
movq 0x38(%rsp), %rcx
movq 0x48(%rsp), %r8
callq 0xb670
jmp 0x13765
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x13714
movq 0x50(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x20000
movq 0x58(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x38(%rsp), %rdx
movq 0x28(%rsp), %rcx
movq 0x40(%rsp), %rax
movl (%rax), %r8d
movq 0x50(%rsp), %r9
movq 0x48(%rsp), %rax
movq %rax, (%rsp)
callq 0x13360
movq %rax, 0x30(%rsp)
movq 0x28(%rsp), %rdi
callq 0x1030
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x1fb30
movq 0x48(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x1fb30
movq 0x30(%rsp), %rax
addq $0x68, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/listSpanningTrees.c
// Function: countNonisomorphicSpanningTrees
int countNonisomorphicSpanningTrees(struct Graph* g, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	int i = 0;

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

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

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

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

	return i;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movl $0x0, 0x2c(%rsp)
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x1f6a0
movq %rax, 0x20(%rsp)
movq 0x40(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
callq 0x12d20
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x138b4
movq 0x10(%rsp), %rax
cmpl $0x0, 0x10(%rax)
je 0x138a2
movq 0x10(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0xb1e0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x9eb0
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
movq (%rsp), %rsi
movq 0x38(%rsp), %rdx
movq 0x30(%rsp), %rcx
callq 0x2c520
movq 0x38(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x1fb30
jmp 0x138a4
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x13841
movq 0x20(%rsp), %rax
movl 0x28(%rax), %eax
movl %eax, 0x2c(%rsp)
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x20000
movq 0x38(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x2d3c0
movl 0x2c(%rsp), %eax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/loading.c
// Function: initCache
void initCache() {
	HEAD_SIZE = malloc(sizeof(size_t));
	*HEAD_SIZE = 2048;
	HEAD_PTR = malloc(sizeof(char*));
	*HEAD_PTR = malloc(*HEAD_SIZE * sizeof(char));

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

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

// Assembly:
pushq %rax
movl $0x8, %edi
callq 0x1170
movq %rax, 0x2a4ee(%rip)     # 0x3e190
movq 0x2a4e7(%rip), %rax     # 0x3e190
movq $0x800, (%rax)          # imm = 0x800
movl $0x8, %edi
callq 0x1170
movq %rax, 0x2a4c7(%rip)     # 0x3e188
movq 0x2a4c8(%rip), %rax     # 0x3e190
movq (%rax), %rdi
shlq $0x0, %rdi
callq 0x1170
movq %rax, %rcx
movq 0x2a4aa(%rip), %rax     # 0x3e188
movq %rcx, (%rax)
movl $0x8, %edi
callq 0x1170
movq %rax, 0x2a4ae(%rip)     # 0x3e1a0
movq 0x2a4a7(%rip), %rax     # 0x3e1a0
movq $0x800, (%rax)          # imm = 0x800
movl $0x8, %edi
callq 0x1170
movq %rax, 0x2a487(%rip)     # 0x3e198
movq 0x2a488(%rip), %rax     # 0x3e1a0
movq (%rax), %rdi
shlq $0x0, %rdi
callq 0x1170
movq %rax, %rcx
movq 0x2a46a(%rip), %rax     # 0x3e198
movq %rcx, (%rax)
movl $0x8, %edi
callq 0x1170
movq %rax, 0x2a46e(%rip)     # 0x3e1b0
movq 0x2a467(%rip), %rax     # 0x3e1b0
movq $0x800, (%rax)          # imm = 0x800
movl $0x8, %edi
callq 0x1170
movq %rax, 0x2a447(%rip)     # 0x3e1a8
movq 0x2a448(%rip), %rax     # 0x3e1b0
movq (%rax), %rdi
shlq $0x0, %rdi
callq 0x1170
movq %rax, %rcx
movq 0x2a42a(%rip), %rax     # 0x3e1a8
movq %rcx, (%rax)
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/loading.c
// Function: createFileIterator
void createFileIterator(char* filename, struct GraphPool* p) {

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

}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rdi
leaq 0x213ae(%rip), %rsi     # 0x35158
callq 0x11b0
movq %rax, 0x2a3c2(%rip)     # 0x3e178
cmpq $0x0, %rax
je 0x13dcf
movq 0x8(%rsp), %rax
movq %rax, 0x2a3b8(%rip)     # 0x3e180
callq 0x13c90
jmp 0x13de2
movq 0x10(%rsp), %rsi
leaq 0x2188c(%rip), %rdi     # 0x35667
movb $0x0, %al
callq 0x1090
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/loading.c
// Function: destroyFileIterator
void destroyFileIterator() {
	fclose(FI_DATABASE);
	
	free(HEAD_SIZE);
	free(*HEAD_PTR);
	free(HEAD_PTR);
	HEAD_PTR = NULL;
	HEAD_SIZE = NULL;

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

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

// Assembly:
pushq %rax
movq 0x2a350(%rip), %rdi     # 0x3e178
callq 0x1070
movq 0x2a35c(%rip), %rdi     # 0x3e190
callq 0x1030
movq 0x2a348(%rip), %rax     # 0x3e188
movq (%rax), %rdi
callq 0x1030
movq 0x2a339(%rip), %rdi     # 0x3e188
callq 0x1030
movq $0x0, 0x2a329(%rip) # 0x3e188
movq $0x0, 0x2a326(%rip) # 0x3e190
movq 0x2a32f(%rip), %rdi     # 0x3e1a0
callq 0x1030
movq 0x2a31b(%rip), %rax     # 0x3e198
movq (%rax), %rdi
callq 0x1030
movq 0x2a30c(%rip), %rdi     # 0x3e198
callq 0x1030
movq $0x0, 0x2a2fc(%rip) # 0x3e198
movq $0x0, 0x2a2f9(%rip) # 0x3e1a0
movq 0x2a302(%rip), %rdi     # 0x3e1b0
callq 0x1030
movq 0x2a2ee(%rip), %rax     # 0x3e1a8
movq (%rax), %rdi
callq 0x1030
movq 0x2a2df(%rip), %rdi     # 0x3e1a8
callq 0x1030
movq $0x0, 0x2a2cf(%rip) # 0x3e1a8
movq $0x0, 0x2a2cc(%rip) # 0x3e1b0
popq %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/loading.c
// Function: parseHeader
static inline int parseHeader(int* id, int* activity, int* n, int* m) { 
	const char *current = *HEAD_PTR + 1;
	if ((*HEAD_PTR)[0] != '#') { 
		return -1; 
	}

	*id = fastAtoiAgnostic(&current);
	int agnostic_errors = AGNOSTIC_ERROR;
	*activity = fastAtoiAgnostic(&current);
	agnostic_errors += AGNOSTIC_ERROR;
	*n = fastAtoi(&current);
	*m = fastAtoi(&current);
	/* return number of correctly read items.
		See: C11(ISO/IEC 9899:201x) §6.5.8 Relational operators */
	return 2 - agnostic_errors + (*n != -1) + (*m != -1);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq 0x29d49(%rip), %rax     # 0x3e188
movq (%rax), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
movq 0x29d36(%rip), %rax     # 0x3e188
movq (%rax), %rax
movsbl (%rax), %eax
cmpl $0x23, %eax
je 0x1446a
movl $0xffffffff, 0x34(%rsp) # imm = 0xFFFFFFFF
jmp 0x14501
leaq 0x8(%rsp), %rdi
callq 0x15890
movl %eax, %ecx
movq 0x28(%rsp), %rax
movl %ecx, (%rax)
movl 0x29cbd(%rip), %eax     # 0x3e140
movl %eax, 0x4(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x15890
movl %eax, %ecx
movq 0x20(%rsp), %rax
movl %ecx, (%rax)
movl 0x29ca0(%rip), %eax     # 0x3e140
addl 0x4(%rsp), %eax
movl %eax, 0x4(%rsp)
leaq 0x8(%rsp), %rdi
callq 0x159a0
movl %eax, %ecx
movq 0x18(%rsp), %rax
movl %ecx, (%rax)
leaq 0x8(%rsp), %rdi
callq 0x159a0
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, (%rax)
movl $0x2, %eax
subl 0x4(%rsp), %eax
movq 0x18(%rsp), %rcx
cmpl $-0x1, (%rcx)
setne %cl
andb $0x1, %cl
movzbl %cl, %ecx
addl %ecx, %eax
movq 0x10(%rsp), %rcx
cmpl $-0x1, (%rcx)
setne %cl
andb $0x1, %cl
movzbl %cl, %ecx
addl %ecx, %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/loading.c
// Function: grabLabel
static inline int grabLabel(const char** currentPosition, char** label) {
	size_t offset;
	size_t labelSize;
	*label = NULL;
	fastLabelLength(*currentPosition, &offset, &labelSize);
	if (labelSize != 0) {
		if ((*label = malloc((labelSize + 1) * sizeof(char)))) {
			memcpy(*label, *currentPosition + offset, labelSize);
			(*label)[labelSize] = '\0';
			*currentPosition += offset + labelSize;	
			return labelSize;
		}
	} 
	return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq $0x0, (%rax)
movq 0x18(%rsp), %rax
movq (%rax), %rdi
leaq 0x8(%rsp), %rsi
movq %rsp, %rdx
callq 0x15a80
cmpq $0x0, (%rsp)
je 0x145b3
movq (%rsp), %rdi
addq $0x1, %rdi
shlq $0x0, %rdi
callq 0x1170
movq 0x10(%rsp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
je 0x145b1
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x18(%rsp), %rax
movq (%rax), %rsi
addq 0x8(%rsp), %rsi
movq (%rsp), %rdx
callq 0x1150
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq (%rsp), %rcx
movb $0x0, (%rax,%rcx)
movq 0x8(%rsp), %rcx
addq (%rsp), %rcx
movq 0x18(%rsp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
movq (%rsp), %rax
movl %eax, 0x24(%rsp)
jmp 0x145bb
jmp 0x145b3
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/loading.c
// Function: parseEdgeNew
static inline int parseEdgeNew(const char** currentPosition, int* v, int* w, char** label) {
	*v = fastAtoi(currentPosition);
	*w = fastAtoi(currentPosition);
	grabLabel(currentPosition, label);
	return (*v != -1) + (*w != -1) + (*label != NULL);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x20(%rsp), %rdi
callq 0x159a0
movl %eax, %ecx
movq 0x18(%rsp), %rax
movl %ecx, (%rax)
movq 0x20(%rsp), %rdi
callq 0x159a0
movl %eax, %ecx
movq 0x10(%rsp), %rax
movl %ecx, (%rax)
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x14510
movq 0x18(%rsp), %rax
cmpl $-0x1, (%rax)
setne %al
andb $0x1, %al
movzbl %al, %eax
movq 0x10(%rsp), %rcx
cmpl $-0x1, (%rcx)
setne %cl
andb $0x1, %cl
movzbl %cl, %ecx
addl %ecx, %eax
movq 0x8(%rsp), %rcx
cmpq $0x0, (%rcx)
setne %cl
andb $0x1, %cl
movzbl %cl, %ecx
addl %ecx, %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/loading.c
// Function: intLabel
char* intLabel(const unsigned int label) {
	int bufferSize;
	char* representation;
	
	if (label>1) {
		bufferSize = (int)ceil(log10(label)) + 2;
	} else {
		bufferSize = 3;
	}

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

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
cmpl $0x1, 0x14(%rsp)
jbe 0x14b0f
movl 0x14(%rsp), %eax
cvtsi2sd %rax, %xmm0
callq 0x1130
callq 0x1210
cvttsd2si %xmm0, %eax
addl $0x2, %eax
movl %eax, 0x10(%rsp)
jmp 0x14b17
movl $0x3, 0x10(%rsp)
movslq 0x10(%rsp), %rdi
shlq $0x0, %rdi
callq 0x1170
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x14b49
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %edx
leaq 0x21ab2(%rip), %rsi     # 0x365f4
movb $0x0, %al
callq 0x11f0
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/loading.c
// Function: fastAtoiAgnostic
static inline int fastAtoiAgnostic( const char ** pos )
{
   const char *p = *pos;



   for ( ; isspace(*p); p++) {}
   const char *start = p;
   int x;
   if (*p == '-') {
	   x = -1;
   } else {
	   x = 1;
	   --p;
   }

   int n = 0;
   unsigned int d;
   while ((d = digitValue(*++p)) <= 9)
   {
      n = n * 10 + d;
   }


   if (start != p) {
	   // move pointer
	   *pos = p;
	   AGNOSTIC_ERROR = 0;
	   return x*n;
   } else {
	   // return error code
	   AGNOSTIC_ERROR = 1;
	   return 0;
   }

}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x20(%rsp)
callq 0x1230
movq (%rax), %rax
movq 0x20(%rsp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0x158d9
jmp 0x158c9
movq 0x20(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x20(%rsp)
jmp 0x158a6
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x2d, %eax
jne 0x158fa
movl $0xffffffff, 0x14(%rsp) # imm = 0xFFFFFFFF
jmp 0x15910
movl $0x1, 0x14(%rsp)
movq 0x20(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x20(%rsp)
movl $0x0, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x20(%rsp)
movsbl 0x1(%rax), %edi
callq 0x15a70
movl %eax, 0xc(%rsp)
cmpl $0x9, %eax
ja 0x1594a
imull $0xa, 0x10(%rsp), %eax
addl 0xc(%rsp), %eax
movl %eax, 0x10(%rsp)
jmp 0x15918
movq 0x18(%rsp), %rax
cmpq 0x20(%rsp), %rax
je 0x1597c
movq 0x20(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, (%rax)
movl $0x0, 0x287d3(%rip)     # 0x3e140
movl 0x14(%rsp), %eax
imull 0x10(%rsp), %eax
movl %eax, 0x34(%rsp)
jmp 0x1598e
movl $0x1, 0x287ba(%rip)     # 0x3e140
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/loading.c
// Function: fastAtoi
static inline int fastAtoi( const char ** pos )
{
	const char *p = *pos;
	unsigned int d;
	unsigned int n=0;

	for ( ; isspace(*p); p++) {}
	const char* start = p;
	--p;
	while ((d = digitValue(*++p)) <= 9)
	{
		n = n * 10 + d;
	}

	if (start != p) {
		*pos = p;
		return n;
	} else {
		return -1;
	}
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0x8(%rsp)
callq 0x1230
movq (%rax), %rax
movq 0x10(%rsp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0x159f1
jmp 0x159e1
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x159be
movq 0x10(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, %rcx
addq $0x1, %rcx
movq %rcx, 0x10(%rsp)
movsbl 0x1(%rax), %edi
callq 0x15a70
movl %eax, 0xc(%rsp)
cmpl $0x9, %eax
ja 0x15a3a
imull $0xa, 0x8(%rsp), %eax
addl 0xc(%rsp), %eax
movl %eax, 0x8(%rsp)
jmp 0x15a08
movq (%rsp), %rax
cmpq 0x10(%rsp), %rax
je 0x15a5c
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movl 0x8(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0x15a64
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/loading.c
// Function: fastLabelLength
static inline void fastLabelLength(const char* pos, size_t* offset, size_t* labelSize) {
	*offset = 0;
	*labelSize = 0;

    // skip whitespaces
    for ( ; isspace(*pos); pos++) {
    	++(*offset);
    }

    // get labelSize
    for ( ; !isspace(*pos); pos++) {
		++(*labelSize);
    }
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
movq (%rsp), %rax
movq $0x0, (%rax)
callq 0x1230
movq (%rax), %rax
movq 0x10(%rsp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
je 0x15ae9
movq 0x8(%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x15aa9
jmp 0x15aeb
callq 0x1230
movq (%rax), %rax
movq 0x10(%rsp), %rcx
movsbl (%rcx), %ecx
movslq %ecx, %rcx
movzwl (%rax,%rcx,2), %eax
andl $0x2000, %eax           # imm = 0x2000
cmpl $0x0, %eax
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x15b15
jmp 0x15b33
movq (%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x15aeb
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/localEasiness.c
// Function: getMaxLocalEasiness
int getMaxLocalEasiness(struct Graph* g, long int maxBound, struct GraphPool* gp, struct ShallowGraphPool* sgp) {

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

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq $-0x1, 0x18(%rsp)
movq 0x38(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x10700
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0x38(%rsp), %rax
movl (%rax), %esi
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rcx
movq 0x20(%rsp), %r8
callq 0x15b40
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x20000
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
movq 0x38(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x15e60
movq 0x8(%rsp), %rax
movslq 0x4(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x15e29
movl $0xffffffff, 0x44(%rsp) # imm = 0xFFFFFFFF
jmp 0x15e8e
movq 0x8(%rsp), %rax
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rax
cmpq 0x18(%rsp), %rax
jle 0x15e51
movq 0x8(%rsp), %rax
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x18(%rsp)
jmp 0x15e53
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x15e01
movq 0x8(%rsp), %rdi
callq 0x1030
cmpq $0x7fffffff, 0x18(%rsp) # imm = 0x7FFFFFFF
jle 0x15e7f
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, (%rsp)
jmp 0x15e87
movq 0x18(%rsp), %rax
movl %eax, (%rsp)
movl (%rsp), %eax
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/localEasiness.c
// Function: getMinLocalEasiness
int getMinLocalEasiness(struct Graph* g, long int maxBound, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	long int min = -1;
	struct ShallowGraph* biconnectedComponents = listBiconnectedComponents(g, sgp);
	long int* easiness = computeLocalEasinessExactly(biconnectedComponents, g->n, maxBound, gp, sgp);
	dumpShallowGraphCycle(sgp, biconnectedComponents);
	for (int v=0; v<g->n; ++v) {
		// error occurred. skip it.
		if (easiness[v] == 0) {
			continue;
		}
		if ((easiness[v] < min) || (min == -1)) {
			min = easiness[v];
		}
	}
	free(easiness);
	return (min > (long int)INT_MAX) ? -1 : (int)min;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq $-0x1, 0x20(%rsp)
movq 0x40(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x10700
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq 0x40(%rsp), %rax
movl (%rax), %esi
movq 0x38(%rsp), %rdx
movq 0x30(%rsp), %rcx
movq 0x28(%rsp), %r8
callq 0x15b40
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x20000
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x40(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x15f70
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
jne 0x15f31
jmp 0x15f63
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rax
cmpq 0x20(%rsp), %rax
jl 0x15f4e
cmpq $-0x1, 0x20(%rsp)
jne 0x15f61
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x20(%rsp)
jmp 0x15f63
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x15f11
movq 0x10(%rsp), %rdi
callq 0x1030
cmpq $0x7fffffff, 0x20(%rsp) # imm = 0x7FFFFFFF
jle 0x15f90
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
movl %eax, 0x8(%rsp)
jmp 0x15f99
movq 0x20(%rsp), %rax
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/localEasySubtreeIsomorphism.c
// Function: lowPointComparator
static int lowPointComparator(const void* a, const void* b) {
	struct Vertex* v = *(struct Vertex**)a;
	struct Vertex* w = *(struct Vertex**)b;

	int depthDiff = v->lowPoint - w->lowPoint;
	int parentDepthDiff = v->visited - w->visited;
	return (depthDiff != 0) ? depthDiff : parentDepthDiff;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rsp)
movq -0x18(%rsp), %rax
movl 0x20(%rax), %eax
movq -0x20(%rsp), %rcx
subl 0x20(%rcx), %eax
movl %eax, -0x24(%rsp)
movq -0x18(%rsp), %rax
movl 0x1c(%rax), %eax
movq -0x20(%rsp), %rcx
subl 0x1c(%rcx), %eax
movl %eax, -0x28(%rsp)
cmpl $0x0, -0x24(%rsp)
je 0x1640d
movl -0x24(%rsp), %eax
movl %eax, -0x2c(%rsp)
jmp 0x16415
movl -0x28(%rsp), %eax
movl %eax, -0x2c(%rsp)
movl -0x2c(%rsp), %eax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/localEasySubtreeIsomorphism.c
// Function: popShallowGraph
static struct ShallowGraph* popShallowGraph(struct ShallowGraph** list) {
	struct ShallowGraph* head = *list;
	if (head != NULL) {
		*list = (*list)->next;
		head->next = NULL;
	}
	return head;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rsp)
cmpq $0x0, -0x10(%rsp)
je 0x1645b
movq -0x8(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rcx
movq -0x8(%rsp), %rax
movq %rcx, (%rax)
movq -0x10(%rsp), %rax
movq $0x0, 0x18(%rax)
movq -0x10(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/localEasySubtreeIsomorphism.c
// Function: spanningTreeConverter
struct Graph* spanningTreeConverter(struct ShallowGraph* localTrees, struct Graph* component, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	struct Graph* resultingTrees = NULL;
	for (struct ShallowGraph* tree=popShallowGraph(&localTrees); tree!=NULL; tree=popShallowGraph(&localTrees)) {

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

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

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq $0x0, 0x30(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x16420
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x1683f
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0xb7c0
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rax
movl 0x10(%rax), %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x4(%rax)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x1678c
movq 0x48(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x1c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movl 0x28(%rax), %ecx
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x1c(%rsp), %rdx
movq (%rax,%rdx,8), %rax
movl %ecx, 0x28(%rax)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x16748
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xbc00
movq 0x28(%rsp), %rdi
callq 0xbef0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x16804
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0xa660
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x40(%rsp), %rax
movq 0x18(%rax), %rsi
callq 0xa370
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0xa660
movq 0x28(%rsp), %rdi
callq 0xbef0
movq %rax, 0x10(%rsp)
jmp 0x167aa
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x1ff70
movq 0x30(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x20(%rsp), %rax
movq %rax, 0x30(%rsp)
leaq 0x50(%rsp), %rdi
callq 0x16420
movq %rax, 0x28(%rsp)
jmp 0x16710
movq 0x30(%rsp), %rax
addq $0x58, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/localEasySubtreeIsomorphism.c
// Function: compareEdgesAbsolute
int compareEdgesAbsolute(const struct VertexList* e, const struct VertexList* f) {
	int es, ee, fs, fe = 0;
//	if (e == NULL) {
//		if (f == NULL) {
//			return 0;
//		} else {
//			return -1;
//		}
//	} else {
//		if (f == NULL) {
//			return 1;
//		}
//	}
	if (e->startPoint->number < e->endPoint->number) {
		es = e->startPoint->number;
		ee = e->endPoint->number;
	} else {
		es = e->endPoint->number;
		ee = e->startPoint->number;
	}

	if (f->startPoint->number < f->endPoint->number) {
		fs = f->startPoint->number;
		fe = f->endPoint->number;
	} else {
		fs = f->endPoint->number;
		fe = f->startPoint->number;
	}

	if (es != fs) {
		return es - fs;
	}
	if (ee != fe) {
		return ee - fe;
	}
	return labelCmp(e->label, f->label);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movl $0x0, (%rsp)
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movl 0x18(%rax), %eax
movq 0x18(%rsp), %rcx
movq 0x18(%rcx), %rcx
cmpl 0x18(%rcx), %eax
jge 0x16911
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movl 0x18(%rax), %eax
movl %eax, 0xc(%rsp)
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rax
movl 0x18(%rax), %eax
movl %eax, 0x8(%rsp)
jmp 0x16931
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rax
movl 0x18(%rax), %eax
movl %eax, 0xc(%rsp)
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movl 0x18(%rax), %eax
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movl 0x18(%rax), %eax
movq 0x10(%rsp), %rcx
movq 0x18(%rcx), %rcx
cmpl 0x18(%rcx), %eax
jge 0x1696c
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movl 0x18(%rax), %eax
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movl 0x18(%rax), %eax
movl %eax, (%rsp)
jmp 0x1698b
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movl 0x18(%rax), %eax
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movl 0x18(%rax), %eax
movl %eax, (%rsp)
movl 0xc(%rsp), %eax
cmpl 0x4(%rsp), %eax
je 0x169a3
movl 0xc(%rsp), %eax
subl 0x4(%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0x169d2
movl 0x8(%rsp), %eax
cmpl (%rsp), %eax
je 0x169b9
movl 0x8(%rsp), %eax
subl (%rsp), %eax
movl %eax, 0x24(%rsp)
jmp 0x169d2
movq 0x18(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rsi
callq 0x2dcf0
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax,%rax)