LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/sampleSubtrees.c
// Function: runForEachConnectedComponent
struct ShallowGraph* runForEachConnectedComponent(struct ShallowGraph* (*sampler)(struct Graph*, int, long int, struct GraphPool*, struct ShallowGraphPool*), 
	struct Graph* g, int k, long int threshold, char rebase, struct GraphPool* gp, struct ShallowGraphPool* sgp) {

	struct ShallowGraph* results = NULL;
	struct Graph* connectedComponents = listConnectedComponents(g, gp);

	struct Graph* current;
	for (current=connectedComponents; current!=NULL; current=current->next) {
		struct ShallowGraph* currentResult = sampler(current, k, threshold, gp, sgp);

		// find last element in currentResult
		struct ShallowGraph* idx;	
		for (idx=currentResult; idx->next!=NULL; idx=idx->next);

		// add previous results after last element, reset results to head of current results
		if (idx) {
			idx->next = results;
			results = currentResult;
		}
	}

	// due to this line, the returned shallow graphs are pointing to g, but this
	// requires the sampler function to not alter the ->lowPoints of the vertices
	if (rebase) { rebaseShallowGraphsOnLowPoints(results, g); }
	dumpGraphList(gp, connectedComponents);
	return results;
}

// Assembly:
subq $0x58, %rsp
movb %r8b, %al
movq 0x60(%rsp), %r8
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movl %edx, 0x44(%rsp)
movq %rcx, 0x38(%rsp)
movb %al, 0x37(%rsp)
movq %r9, 0x28(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x48(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x10ab0
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x2bb9f
movq 0x50(%rsp), %rax
movq 0x10(%rsp), %rdi
movl 0x44(%rsp), %esi
movq 0x38(%rsp), %rdx
movq 0x28(%rsp), %rcx
movq 0x60(%rsp), %r8
callq *%rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x2bb6f
jmp 0x2bb61
movq (%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, (%rsp)
jmp 0x2bb54
cmpq $0x0, (%rsp)
je 0x2bb8d
movq 0x20(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x2bb8f
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x2bb1f
cmpb $0x0, 0x37(%rsp)
je 0x2bbb5
movq 0x20(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0xbcb0
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x1fc60
movq 0x20(%rsp), %rax
addq $0x58, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/sampleSubtrees.c
// Function: getNumberOfNonisomorphicSpanningForestComponentsForKSamples
int getNumberOfNonisomorphicSpanningForestComponentsForKSamples(struct Graph* g, int k, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	int numberOfNonisomorphicSpanningTreeComponents = 0;

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

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

	numberOfNonisomorphicSpanningTreeComponents = searchTree->d;

	// avoid memory leaks, access to freed memory, and free unused stuff
	dumpShallowGraphCycle(sgp, sample);
	dumpSearchTree(gp, searchTree);

	return numberOfNonisomorphicSpanningTreeComponents;

}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movl $0x0, 0x34(%rsp)
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x1f6a0
movq %rax, 0x28(%rsp)
movq 0x50(%rsp), %rsi
movl 0x4c(%rsp), %edx
movslq 0x4c(%rsp), %rcx
movq 0x40(%rsp), %r9
movq 0x38(%rsp), %rax
leaq -0xbf1(%rip), %rdi      # 0x2b030
movl $0x1, %r8d
movq %rax, (%rsp)
callq 0x2bad0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x2bcb7
movq 0x18(%rsp), %rax
cmpl $0x0, 0x10(%rax)
je 0x2bca5
movq 0x18(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0xb1e0
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x9eb0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
movq 0x40(%rsp), %rdx
movq 0x38(%rsp), %rcx
callq 0x2c520
movq 0x40(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x1fb30
jmp 0x2bca7
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
jmp 0x2bc3f
movq 0x28(%rsp), %rax
movl 0x28(%rax), %eax
movl %eax, 0x34(%rsp)
movq 0x38(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x20000
movq 0x40(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x2d3c0
movl 0x34(%rsp), %eax
addq $0x58, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/searchTree.c
// Function: addStringToSearchTreeSetDRec
static char addStringToSearchTreeSetDRec(struct Vertex* root, struct VertexList* edge, int d, int id, struct GraphPool* p) {

	/* if edge == NULL, stop recursion, remember, that some string ends here */
	if (edge == NULL) {
		root->visited += 1;
		root->d = d;
		if (root->visited == 1) {
			root->lowPoint = id;
			return 1;
		} else {
			return 0;
		}
	} else {
		struct VertexList* idx;
		for (idx=root->neighborhood; idx; idx=idx->next) {
			/* if the next label is already in the tree, continue recursively */
			if (strcmp(idx->label, edge->label) == 0) {
				char isNew = addStringToSearchTreeSetDRec(idx->endPoint, edge->next, d, id, p);
				/* edges dangling at edge are consumed or dumped by the following recursion steps */
				edge->next = NULL;
				dumpVertexList(p->listPool, edge);
				return isNew;
			}
		}

		/* otherwise add the current edge to the tree and continue recursively */
		idx = edge->next;
		edge->startPoint = root;
		edge->endPoint = getVertex(p->vertexPool);
		addEdge(root, edge);
		return addStringToSearchTreeSetDRec(edge->endPoint, idx, d, id, p);
	}
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movl %ecx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x2bf98
movq 0x28(%rsp), %rax
movl 0x1c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x1c(%rax)
movl 0x1c(%rsp), %ecx
movq 0x28(%rsp), %rax
movl %ecx, 0x28(%rax)
movq 0x28(%rsp), %rax
cmpl $0x1, 0x1c(%rax)
jne 0x2bf8e
movl 0x18(%rsp), %ecx
movq 0x28(%rsp), %rax
movl %ecx, 0x20(%rax)
movb $0x1, 0x37(%rsp)
jmp 0x2c09c
movb $0x0, 0x37(%rsp)
jmp 0x2c09c
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x2c033
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movq 0x20(%rsp), %rax
movq (%rax), %rsi
callq 0x1120
cmpl $0x0, %eax
jne 0x2c01e
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rsi
movl 0x1c(%rsp), %edx
movl 0x18(%rsp), %ecx
movq 0x10(%rsp), %r8
callq 0x2bf30
movb %al, 0x7(%rsp)
movq 0x20(%rsp), %rax
movq $0x0, 0x8(%rax)
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x20(%rsp), %rsi
callq 0x1f410
movb 0x7(%rsp), %al
movb %al, 0x37(%rsp)
jmp 0x2c09c
jmp 0x2c020
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x2bfa6
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x1f6a0
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xa660
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x8(%rsp), %rsi
movl 0x1c(%rsp), %edx
movl 0x18(%rsp), %ecx
movq 0x10(%rsp), %r8
callq 0x2bf30
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/searchTree.c
// Function: addStringToSearchTreeSetVisitedRec
static char addStringToSearchTreeSetVisitedRec(struct Vertex* root, struct VertexList* edge, int visited, int id, struct GraphPool* p) {

	/* if edge == NULL, stop recursion, remember, that some string ends here */
	if (edge == NULL) {
		root->visited += visited;
		if (root->visited == visited) {
			root->lowPoint = id;
			return 1;
		} else {
			return 0;
		}
	} else {
		struct VertexList* idx;
		for (idx=root->neighborhood; idx; idx=idx->next) {
			/* if the next label is already in the tree, continue recursively */
			if (strcmp(idx->label, edge->label) == 0) {
				char isNew = addStringToSearchTreeSetVisitedRec(idx->endPoint, edge->next, visited, id, p);
				/* edges dangling at edge are consumed or dumped by the following recursion steps */
				edge->next = NULL;
				dumpVertexList(p->listPool, edge);
				return isNew;
			}
		}

		/* otherwise add the current edge to the tree and continue recursively */
		idx = edge->next;
		edge->startPoint = root;
		edge->endPoint = getVertex(p->vertexPool);
		addEdge(root, edge);
		return addStringToSearchTreeSetVisitedRec(edge->endPoint, idx, visited, id, p);
	}
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl %edx, 0x1c(%rsp)
movl %ecx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
cmpq $0x0, 0x20(%rsp)
jne 0x2c170
movl 0x1c(%rsp), %ecx
movq 0x28(%rsp), %rax
addl 0x1c(%rax), %ecx
movl %ecx, 0x1c(%rax)
movq 0x28(%rsp), %rax
movl 0x1c(%rax), %eax
cmpl 0x1c(%rsp), %eax
jne 0x2c166
movl 0x18(%rsp), %ecx
movq 0x28(%rsp), %rax
movl %ecx, 0x20(%rax)
movb $0x1, 0x37(%rsp)
jmp 0x2c274
movb $0x0, 0x37(%rsp)
jmp 0x2c274
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x2c20b
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movq 0x20(%rsp), %rax
movq (%rax), %rsi
callq 0x1120
cmpl $0x0, %eax
jne 0x2c1f6
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rsi
movl 0x1c(%rsp), %edx
movl 0x18(%rsp), %ecx
movq 0x10(%rsp), %r8
callq 0x2c110
movb %al, 0x7(%rsp)
movq 0x20(%rsp), %rax
movq $0x0, 0x8(%rax)
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x20(%rsp), %rsi
callq 0x1f410
movb 0x7(%rsp), %al
movb %al, 0x37(%rsp)
jmp 0x2c274
jmp 0x2c1f8
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x2c17e
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x1f6a0
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xa660
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x8(%rsp), %rsi
movl 0x1c(%rsp), %edx
movl 0x18(%rsp), %ecx
movq 0x10(%rsp), %r8
callq 0x2c110
movb %al, 0x37(%rsp)
movb 0x37(%rsp), %al
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/searchTree.c
// Function: containsStringRec
static int containsStringRec(struct Vertex* root, struct VertexList* edge) {

	/* if edge == NULL, we are done. check if visited > 0.  */
	if (edge == NULL) {
		return root->visited;
	} else {
		struct VertexList* idx;
		for (idx=root->neighborhood; idx; idx=idx->next) {
			/* if the next label is already in the tree, continue recursively */
			if (strcmp(idx->label, edge->label) == 0) {
				return containsStringRec(idx->endPoint, edge->next);
			}
		}

		/* otherwise string is not contained */
		return 0;
	}
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x2c2d4
movq 0x18(%rsp), %rax
movl 0x1c(%rax), %eax
movl %eax, 0x24(%rsp)
jmp 0x2c33b
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x2c333
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rsi
callq 0x1120
cmpl $0x0, %eax
jne 0x2c321
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0x2c2b0
movl %eax, 0x24(%rsp)
jmp 0x2c33b
jmp 0x2c323
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x2c2e2
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/searchTree.c
// Function: getIDRec
static int getIDRec(struct Vertex* root, struct VertexList* edge) {

	/* if edge == NULL, we are done. check if visited > 0.  */
	if (edge == NULL) {
		if (root->visited > 0) {
			return root->lowPoint;
		} else {
			return -1;
		}
	} else {
		struct VertexList* idx;
		for (idx=root->neighborhood; idx; idx=idx->next) {
			/* if the next label is already in the tree, continue recursively */
			if (strcmp(idx->label, edge->label) == 0) {
				return getIDRec(idx->endPoint, edge->next);		
			}
		}

		/* otherwise string is not contained */
		return -1;
	}
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jne 0x2c3b9
movq 0x18(%rsp), %rax
cmpl $0x0, 0x1c(%rax)
jle 0x2c3af
movq 0x18(%rsp), %rax
movl 0x20(%rax), %eax
movl %eax, 0x24(%rsp)
jmp 0x2c420
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x2c420
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x2c418
movq 0x8(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rsi
callq 0x1120
cmpl $0x0, %eax
jne 0x2c406
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0x2c380
movl %eax, 0x24(%rsp)
jmp 0x2c420
jmp 0x2c408
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x2c3c7
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/searchTree.c
// Function: compInfoComparison
int compInfoComparison(const void* e1, const void* e2) {
	/* TODO move into function call */
	struct compInfo a = *(struct compInfo*)e1;
	struct compInfo b = *(struct compInfo*)e2;

	return a.id - b.id;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq (%rax), %rcx
movq %rcx, -0x1c(%rsp)
movl 0x8(%rax), %eax
movl %eax, -0x14(%rsp)
movq -0x10(%rsp), %rax
movq (%rax), %rcx
movq %rcx, -0x28(%rsp)
movl 0x8(%rax), %eax
movl %eax, -0x20(%rsp)
movl -0x1c(%rsp), %eax
subl -0x28(%rsp), %eax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/searchTree.c
// Function: printSearchTree
void printSearchTree(struct Vertex* root, int level) {
	struct VertexList* index;

	for (index=root->neighborhood; index; index=index->next) {
		printf("l%i ", level);
		printf("(%i, %i) %s\n", index->endPoint->lowPoint, index->endPoint->visited, index->label);
		printSearchTree(index->endPoint, level+1);
	}
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x2c510
movl 0xc(%rsp), %esi
leaq 0x9b44(%rip), %rdi      # 0x36000
movb $0x0, %al
callq 0x1090
movq (%rsp), %rax
movq 0x18(%rax), %rax
movl 0x20(%rax), %esi
movq (%rsp), %rax
movq 0x18(%rax), %rax
movl 0x1c(%rax), %edx
movq (%rsp), %rax
movq (%rax), %rcx
leaq 0x9b1e(%rip), %rdi      # 0x36005
movb $0x0, %al
callq 0x1090
movq (%rsp), %rax
movq 0x18(%rax), %rdi
movl 0xc(%rsp), %esi
addl $0x1, %esi
callq 0x2c490
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
jmp 0x2c4aa
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/searchTree.c
// Function: addToSearchTree
struct Vertex* addToSearchTree(struct Vertex* root, struct ShallowGraph* strings, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	struct ShallowGraph *idx;

	for (idx=strings; idx; idx=idx->next) {
		root->d += addStringToSearchTree(root, idx->edges, gp);
		root->number += 1;

		idx->edges = NULL;
	}

	dumpShallowGraphCycle(sgp, strings);

	return root;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x2c593
movq 0x20(%rsp), %rdi
movq (%rsp), %rax
movq (%rax), %rsi
movq 0x10(%rsp), %rdx
callq 0x2bcf0
movsbl %al, %ecx
movq 0x20(%rsp), %rax
addl 0x28(%rax), %ecx
movl %ecx, 0x28(%rax)
movq 0x20(%rsp), %rax
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x18(%rax)
movq (%rsp), %rax
movq $0x0, (%rax)
movq (%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, (%rsp)
jmp 0x2c541
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x20000
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/searchTree.c
// Function: addMultiSetToSearchTree
struct Vertex* addMultiSetToSearchTree(struct Vertex* root, struct ShallowGraph* strings, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	struct ShallowGraph *idx;

	for (idx=strings; idx; idx=idx->next) {
		root->d += addStringToSearchTreeSetVisited(root, idx->edges, idx->data, gp);
		root->number += idx->data;
		idx->edges = NULL;
	}

	dumpShallowGraphCycle(sgp, strings);

	return root;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq %rcx, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x2c62e
movq 0x20(%rsp), %rdi
movq (%rsp), %rax
movq (%rax), %rsi
movq (%rsp), %rax
movl 0x28(%rax), %edx
movq 0x10(%rsp), %rcx
callq 0x2c0b0
movsbl %al, %ecx
movq 0x20(%rsp), %rax
addl 0x28(%rax), %ecx
movl %ecx, 0x28(%rax)
movq (%rsp), %rax
movl 0x28(%rax), %ecx
movq 0x20(%rsp), %rax
addl 0x18(%rax), %ecx
movl %ecx, 0x18(%rax)
movq (%rsp), %rax
movq $0x0, (%rax)
movq (%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, (%rsp)
jmp 0x2c5d1
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x20000
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/searchTree.c
// Function: resetToUniqueRec
static void resetToUniqueRec(struct Vertex* root, struct Vertex* current) {
	struct VertexList* e;
	if (current != root) {
		if (current->visited > 0) {
			current->visited = 1;
			++root->d;
			++root->number;
		}
	}

	for (e=current->neighborhood; e!=NULL; e=e->next) {
		resetToUniqueRec(root, e->endPoint);
	}
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x10(%rsp), %rax
je 0x2c99f
movq 0x8(%rsp), %rax
cmpl $0x0, 0x1c(%rax)
jle 0x2c99d
movq 0x8(%rsp), %rax
movl $0x1, 0x1c(%rax)
movq 0x10(%rsp), %rax
movl 0x28(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x28(%rax)
movq 0x10(%rsp), %rax
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x18(%rax)
jmp 0x2c99f
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x2c9d3
movq 0x10(%rsp), %rdi
movq (%rsp), %rax
movq 0x18(%rax), %rsi
callq 0x2c950
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
jmp 0x2c9ac
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/searchTree.c
// Function: offsetSearchTreeIdsRec
static void offsetSearchTreeIdsRec(struct Vertex* root, struct Vertex* current, int offset) {
	struct VertexList* e;
	if (current != root) {
		if (current->lowPoint > 0) {
			current->lowPoint += offset;
		}
	}

	for (e=current->neighborhood; e!=NULL; e=e->next) {
		offsetSearchTreeIdsRec(root, e->endPoint, offset);
	}
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq 0x18(%rsp), %rax
cmpq 0x20(%rsp), %rax
je 0x2ca5a
movq 0x18(%rsp), %rax
cmpl $0x0, 0x20(%rax)
jle 0x2ca58
movl 0x14(%rsp), %ecx
movq 0x18(%rsp), %rax
addl 0x20(%rax), %ecx
movl %ecx, 0x20(%rax)
jmp 0x2ca5a
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x2ca97
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rsi
movl 0x14(%rsp), %edx
callq 0x2ca20
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x2ca68
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/searchTree.c
// Function: compressSearchTreeIdsRec
static void compressSearchTreeIdsRec(struct Vertex* root, struct Vertex* current) {
	struct VertexList* e;
	if (current != root) {
		if (current->lowPoint > 0) {
			++root->lowPoint;
			current->lowPoint = root->lowPoint;
		}
	}

	for (e=current->neighborhood; e!=NULL; e=e->next) {
		compressSearchTreeIdsRec(root, e->endPoint);
	}
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x10(%rsp), %rax
je 0x2cb15
movq 0x8(%rsp), %rax
cmpl $0x0, 0x20(%rax)
jle 0x2cb13
movq 0x10(%rsp), %rax
movl 0x20(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x20(%rax)
movq 0x10(%rsp), %rax
movl 0x20(%rax), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x20(%rax)
jmp 0x2cb15
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x2cb49
movq 0x10(%rsp), %rdi
movq (%rsp), %rax
movq 0x18(%rax), %rsi
callq 0x2cad0
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
jmp 0x2cb22
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/searchTree.c
// Function: dumpSearchTree
void dumpSearchTree(struct GraphPool* p, struct Vertex* root) {
	struct VertexList *idx, *tmp;

	idx=root->neighborhood;
	while(idx) {
		dumpSearchTree(p, idx->endPoint);
		tmp = idx;
		idx = idx->next;
		dumpVertexList(p->listPool, tmp);
	}
	dumpVertex(p->vertexPool, root);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x2d424
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rsi
callq 0x2d3c0
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0x1f410
jmp 0x2d3dc
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0x1f810
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/searchTree.c
// Function: shallowCopySearchTree
struct Vertex* shallowCopySearchTree(struct Vertex* original, struct GraphPool* gp) {
	struct Vertex* copy = shallowCopyVertex(original, gp->vertexPool);
	copy->d = original->d;
	copy->lowPoint = original->lowPoint;
	copy->visited = original->visited;

	for (struct VertexList* e=original->neighborhood; e!=NULL; e=e->next) {
		struct VertexList* f = getVertexList(gp->listPool);
		f->label = e->label;
		f->startPoint = copy;
		f->endPoint = shallowCopySearchTree(e->endPoint, gp);
		addEdge(copy, f);
	}

	return copy;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0xa3f0
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movl 0x28(%rax), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x28(%rax)
movq 0x20(%rsp), %rax
movl 0x20(%rax), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x20(%rax)
movq 0x20(%rsp), %rax
movl 0x1c(%rax), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x1c(%rax)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x2d516
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x1f310
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0x2d440
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
callq 0xa660
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x2d4a4
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/searchTree.c
// Function: listStringsInSearchTree
struct ShallowGraph* listStringsInSearchTree(struct Vertex* root, struct ShallowGraphPool* sgp) {
	struct ShallowGraph* listHead = getShallowGraph(sgp);
	struct ShallowGraph* prefix = getShallowGraph(sgp);
	recListString(listHead, root, root, prefix, sgp);
	dumpShallowGraph(sgp, prefix);
	prefix = listHead;
	listHead = listHead->next;
	prefix->next = NULL;
	dumpShallowGraph(sgp, prefix);
	return listHead;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x1fe70
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0x1fe70
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x8(%rsp), %rcx
movq 0x18(%rsp), %r8
callq 0x2d610
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x1ff70
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rax
movq $0x0, 0x18(%rax)
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x1ff70
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/searchTree.c
// Function: recListString
static void recListString(struct ShallowGraph* stringList, struct Vertex* root, struct Vertex* trueRoot, struct ShallowGraph* prefix, struct ShallowGraphPool* sgp) {
	struct VertexList* e;

	if (root != trueRoot) {
		if (root->visited != 0) {
			struct ShallowGraph* tmp = stringList->next;
			stringList->next = cloneShallowGraph(prefix, sgp);
			stringList->next->next = tmp;
		}
	}																																																																								

	for (e=root->neighborhood; e!=NULL; e=e->next) {
		
		/* after finishing this block, we want prefix to be as before, thus we have
		   to do some list magic */																																																								
		struct VertexList* lastEdge = prefix->lastEdge;
		appendEdge(prefix, shallowCopyEdge(e, sgp->listPool));

		recListString(stringList, e->endPoint, root, prefix, sgp);

		dumpVertexList(sgp->listPool, prefix->lastEdge);
		prefix->lastEdge = lastEdge;
		--prefix->m;

		if (prefix->m == 0) {
			prefix->edges = NULL;
		} else {
			lastEdge->next = NULL;
		}	
	}
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq 0x38(%rsp), %rax
cmpq 0x30(%rsp), %rax
je 0x2d681
movq 0x38(%rsp), %rax
cmpl $0x0, 0x1c(%rax)
je 0x2d67f
movq 0x40(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xbe10
movq %rax, %rcx
movq 0x40(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rcx
movq 0x40(%rsp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x18(%rax)
jmp 0x2d681
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x2d761
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0xa310
movq (%rsp), %rdi
movq %rax, %rsi
callq 0xbf70
movq 0x40(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rsi
movq 0x38(%rsp), %rdx
movq 0x28(%rsp), %rcx
movq 0x20(%rsp), %r8
callq 0x2d610
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0x1f410
movq 0x8(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x28(%rsp), %rax
movl 0x10(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x10(%rax)
movq 0x28(%rsp), %rax
cmpl $0x0, 0x10(%rax)
jne 0x2d73f
movq 0x28(%rsp), %rax
movq $0x0, (%rax)
jmp 0x2d74c
movq 0x8(%rsp), %rax
movq $0x0, 0x8(%rax)
jmp 0x2d74e
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
jmp 0x2d68f
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/searchTree.c
// Function: recPrint
static void recPrint(struct Vertex* root, struct Vertex* trueRoot, int offset, struct ShallowGraph* prefix, FILE* stream, struct ShallowGraphPool* sgp) {
	struct VertexList* e;

	if (root != trueRoot) {
		if (root->visited != 0) {
			fprintf(stream, "%i\t%i\t", root->visited + offset, root->lowPoint);
			printCanonicalString(prefix, stream);
		}
	}																																																																								

	for (e=root->neighborhood; e!=NULL; e=e->next) {
		
		/* after finishing this block, we want prefix to be as before, thus we have
		   to do some list magic */																																																								
		struct VertexList* lastEdge = prefix->lastEdge;
		appendEdge(prefix, shallowCopyEdge(e, sgp->listPool));

		recPrint(e->endPoint, root, offset, prefix, stream, sgp);

		dumpVertexList(sgp->listPool, prefix->lastEdge);
		prefix->lastEdge = lastEdge;
		--prefix->m;

		if (prefix->m == 0) {
			prefix->edges = NULL;
		} else {
			lastEdge->next = NULL;
		}
		
	}
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movl %edx, 0x34(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %r9, 0x18(%rsp)
movq 0x40(%rsp), %rax
cmpq 0x38(%rsp), %rax
je 0x2d840
movq 0x40(%rsp), %rax
cmpl $0x0, 0x1c(%rax)
je 0x2d83e
movq 0x20(%rsp), %rdi
movq 0x40(%rsp), %rax
movl 0x1c(%rax), %edx
addl 0x34(%rsp), %edx
movq 0x40(%rsp), %rax
movl 0x20(%rax), %ecx
leaq 0x812c(%rip), %rsi      # 0x35954
movb $0x0, %al
callq 0x1140
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x9130
jmp 0x2d840
movq 0x40(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x2d924
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0xa310
movq (%rsp), %rdi
movq %rax, %rsi
callq 0xbf70
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x40(%rsp), %rsi
movl 0x34(%rsp), %edx
movq 0x28(%rsp), %rcx
movq 0x20(%rsp), %r8
movq 0x18(%rsp), %r9
callq 0x2d7d0
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0x1f410
movq 0x8(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x28(%rsp), %rax
movl 0x10(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x10(%rax)
movq 0x28(%rsp), %rax
cmpl $0x0, 0x10(%rax)
jne 0x2d902
movq 0x28(%rsp), %rax
movq $0x0, (%rax)
jmp 0x2d90f
movq 0x8(%rsp), %rax
movq $0x0, 0x8(%rax)
jmp 0x2d911
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x2d84e
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/searchTree.c
// Function: streamBuildSearchTree
int streamBuildSearchTree(FILE* stream, struct Vertex* root, int bufferSize, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	int number;
	int nPatterns;
	int i;
	char* buffer = malloc(bufferSize * sizeof(char));
	int head = fscanf(stream, "# %i %i\n", &number, &nPatterns);
	int readCount = 0;

	if (head != 2) {
		free(buffer);
		return 0;
	}

	for (i=0; i<nPatterns; ++i) {
		int multiplicity;
		struct ShallowGraph* string;
		readCount += fscanf(stream, "%i\t", &multiplicity);
		string = parseCString(stream, buffer, sgp);
		addToSearchTree(root, string, gp, sgp);
	}

	if (readCount != nPatterns) {
		fprintf(stderr, "Error: Read %i patterns, should have been %i\n", readCount, nPatterns);
	}

	free(buffer);
	return 1;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movq %rsi, 0x50(%rsp)
movl %edx, 0x4c(%rsp)
movq %rcx, 0x40(%rsp)
movq %r8, 0x38(%rsp)
movslq 0x4c(%rsp), %rdi
shlq $0x0, %rdi
callq 0x1170
movq %rax, 0x20(%rsp)
movq 0x58(%rsp), %rdi
leaq 0x8676(%rip), %rsi      # 0x36041
leaq 0x34(%rsp), %rdx
leaq 0x30(%rsp), %rcx
movb $0x0, %al
callq 0x1050
movl %eax, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
cmpl $0x2, 0x1c(%rsp)
je 0x2da06
movq 0x20(%rsp), %rdi
callq 0x1030
movl $0x0, 0x64(%rsp)
jmp 0x2dab3
movl $0x0, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
cmpl 0x30(%rsp), %eax
jge 0x2da77
movq 0x58(%rsp), %rdi
leaq 0x7f33(%rip), %rsi      # 0x35957
leaq 0x14(%rsp), %rdx
movb $0x0, %al
callq 0x1050
addl 0x18(%rsp), %eax
movl %eax, 0x18(%rsp)
movq 0x58(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x38(%rsp), %rdx
callq 0x9300
movq %rax, 0x8(%rsp)
movq 0x50(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x40(%rsp), %rdx
movq 0x38(%rsp), %rcx
callq 0x2c520
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x2da0e
movl 0x18(%rsp), %eax
cmpl 0x30(%rsp), %eax
je 0x2daa1
movq 0x10570(%rip), %rax     # 0x3dff8
movq (%rax), %rdi
movl 0x18(%rsp), %edx
movl 0x30(%rsp), %ecx
leaq 0x8578(%rip), %rsi      # 0x36012
movb $0x0, %al
callq 0x1140
movq 0x20(%rsp), %rdi
callq 0x1030
movl $0x1, 0x64(%rsp)
movl 0x64(%rsp), %eax
addq $0x68, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/searchTree.c
// Function: streamReadPatternsAndTheirNumber
struct ShallowGraph* streamReadPatternsAndTheirNumber(FILE* stream, int bufferSize, int* number, int* nPatterns, struct ShallowGraphPool* sgp) {
	
	int i;
	struct ShallowGraph* patterns = NULL;

	char* buffer = malloc(bufferSize * sizeof(char));
	int head = fscanf(stream, " # %i %i\n", number, nPatterns);
	int writeCount = 0;

	/* fscanf should read 2 values, unless its the end of the file */
	if ((head != 2)) {
		if (head != -1) {
			fprintf(stderr, "Could not read pattern. Wrong number: %i (must be 2)\n", head);
		}
		free(buffer);
		return NULL;
	}

	for (i=0; i<*nPatterns; ++i) {
		int multiplicity;
		int id;
		struct ShallowGraph* string;
		writeCount += fscanf(stream, "%i\t%i\t", &multiplicity, &id);
		string = parseCString(stream, buffer, sgp);
		string->data = multiplicity;
		string->next = patterns;
		patterns = string;
	}	
	
	if (writeCount != *nPatterns * 2) {
		fprintf(stderr, "Error: Wrote %i patterns, should have been %i\n", writeCount, *nPatterns);
	}

	free(buffer);
	return patterns;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x58(%rsp)
movl %esi, 0x54(%rsp)
movq %rdx, 0x48(%rsp)
movq %rcx, 0x40(%rsp)
movq %r8, 0x38(%rsp)
movq $0x0, 0x28(%rsp)
movslq 0x54(%rsp), %rdi
shlq $0x0, %rdi
callq 0x1170
movq %rax, 0x20(%rsp)
movq 0x58(%rsp), %rdi
movq 0x48(%rsp), %rdx
movq 0x40(%rsp), %rcx
leaq 0x84e2(%rip), %rsi      # 0x36040
movb $0x0, %al
callq 0x1050
movl %eax, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
cmpl $0x2, 0x1c(%rsp)
je 0x2dbb3
cmpl $-0x1, 0x1c(%rsp)
je 0x2db9b
movq 0x10472(%rip), %rax     # 0x3dff8
movq (%rax), %rdi
movl 0x1c(%rsp), %edx
leaq 0x84b6(%rip), %rsi      # 0x3604a
movb $0x0, %al
callq 0x1140
movq 0x20(%rsp), %rdi
callq 0x1030
movq $0x0, 0x60(%rsp)
jmp 0x2dc7f
movl $0x0, 0x34(%rsp)
movl 0x34(%rsp), %eax
movq 0x40(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x2dc37
movq 0x58(%rsp), %rdi
leaq 0x7d80(%rip), %rsi      # 0x35954
leaq 0x14(%rsp), %rdx
leaq 0x10(%rsp), %rcx
movb $0x0, %al
callq 0x1050
addl 0x18(%rsp), %eax
movl %eax, 0x18(%rsp)
movq 0x58(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x38(%rsp), %rdx
callq 0x9300
movq %rax, 0x8(%rsp)
movl 0x14(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x28(%rax)
movq 0x28(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x28(%rsp)
movl 0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x34(%rsp)
jmp 0x2dbbb
movl 0x18(%rsp), %eax
movq 0x40(%rsp), %rcx
movl (%rcx), %ecx
shll %ecx
cmpl %ecx, %eax
je 0x2dc6b
movq 0x103a9(%rip), %rax     # 0x3dff8
movq (%rax), %rdi
movl 0x18(%rsp), %edx
movq 0x40(%rsp), %rax
movl (%rax), %ecx
leaq 0x841c(%rip), %rsi      # 0x36080
movb $0x0, %al
callq 0x1140
movq 0x20(%rsp), %rdi
callq 0x1030
movq 0x28(%rsp), %rax
movq %rax, 0x60(%rsp)
movq 0x60(%rsp), %rax
addq $0x68, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/searchTree.c
// Function: loadSearchTree
struct Vertex* loadSearchTree(FILE* stream, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	struct Vertex* root = getVertex(gp->vertexPool);
	int bufferSize = CS_STRING_CACHE_SIZE;
	streamBuildSearchTree(stream, root, bufferSize, gp, sgp);
	return root;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x1f6a0
movq %rax, 0x8(%rsp)
movl $0x800, 0x4(%rsp)       # imm = 0x800
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
movl 0x4(%rsp), %edx
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %r8
callq 0x2d990
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/subtreeIsoUtils.c
// Function: getPostorderOfTree
int* getPostorderOfTree(struct Graph* g, int root) {
	int* order = malloc(g->n * sizeof(int));
	for (int i=0; i<g->n; ++i) {
		g->vertices[i]->visited = -1;
		order[i] = -1;
	}
	dfs(g->vertices[root], 0);
	g->vertices[root]->lowPoint = -1;
	for (int i=0; i<g->n; ++i) {
		if (g->vertices[i]->visited != -1) {
			order[g->vertices[i]->visited] = i;
		} else {
			/* should never happen if g is a tree */
			fprintf(stderr, "Vertex %i was not visited by dfs.\nThis can not happen, if g is a tree.\n", i);
		}
	}
	return order;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq 0x20(%rsp), %rax
movslq (%rax), %rdi
shlq $0x2, %rdi
callq 0x1170
movq %rax, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x2ddaf
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movl $0xffffffff, 0x1c(%rax) # imm = 0xFFFFFFFF
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
movl $0xffffffff, (%rax,%rcx,4) # imm = 0xFFFFFFFF
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x2dd6b
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x1c(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
xorl %esi, %esi
callq 0x2de70
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x1c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movl $0xffffffff, 0x20(%rax) # imm = 0xFFFFFFFF
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x2de5d
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rax
cmpl $-0x1, 0x1c(%rax)
je 0x2de32
movl 0x8(%rsp), %edx
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
movq 0x10(%rcx), %rcx
movslq 0x8(%rsp), %rsi
movq (%rcx,%rsi,8), %rcx
movslq 0x1c(%rcx), %rcx
movl %edx, (%rax,%rcx,4)
jmp 0x2de4e
movq 0x101bf(%rip), %rax     # 0x3dff8
movq (%rax), %rdi
movl 0x8(%rsp), %edx
leaq 0x8268(%rip), %rsi      # 0x360af
movb $0x0, %al
callq 0x1140
jmp 0x2de50
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x2dde9
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/subtreeIsoUtils.c
// Function: dfs
static int dfs(struct Vertex* v, int value) {

	/* to make this method save for graphs that are not trees */
	v->visited = -2;

	for (struct VertexList* e=v->neighborhood; e!=NULL; e=e->next) {
		if (e->endPoint->visited == -1) {
			value = 1 + dfs(e->endPoint, value);
			e->endPoint->lowPoint = v->number;
		}
	}
	v->visited = value;
	return value;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rax
movl $0xfffffffe, 0x1c(%rax) # imm = 0xFFFFFFFE
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x2dee6
movq (%rsp), %rax
movq 0x18(%rax), %rax
cmpl $-0x1, 0x1c(%rax)
jne 0x2ded6
movq (%rsp), %rax
movq 0x18(%rax), %rdi
movl 0xc(%rsp), %esi
callq 0x2de70
addl $0x1, %eax
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rax
movl 0x18(%rax), %ecx
movq (%rsp), %rax
movq 0x18(%rax), %rax
movl %ecx, 0x20(%rax)
jmp 0x2ded8
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
jmp 0x2de96
movl 0xc(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x1c(%rax)
movl 0xc(%rsp), %eax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/subtreeIsoUtils.c
// Function: getPostorder
int* getPostorder(struct Graph* g, int root) {
	if (g->n > 0) {
		int* order = malloc(g->n * sizeof(int));
		for (int i=0; i<g->n; ++i) {
			g->vertices[i]->visited = -1;
			order[i] = -1;
		}

		int nVisited = dfs(g->vertices[root], 0);
		g->vertices[root]->lowPoint = -1;
		for (int i=0; i<g->n; ++i) {
			if (g->vertices[i]->visited == -1) {
				nVisited = dfs(g->vertices[i], nVisited + 1);
				g->vertices[i]->lowPoint = -1;

			}
			order[g->vertices[i]->visited] = i;
		}
		return order;
	} else {
		return NULL;
	}
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq 0x28(%rsp), %rax
cmpl $0x0, (%rax)
jle 0x2e05d
movq 0x28(%rsp), %rax
movslq (%rax), %rdi
shlq $0x2, %rdi
callq 0x1170
movq %rax, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq 0x28(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x2df7d
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movl $0xffffffff, 0x1c(%rax) # imm = 0xFFFFFFFF
movq 0x18(%rsp), %rax
movslq 0x14(%rsp), %rcx
movl $0xffffffff, (%rax,%rcx,4) # imm = 0xFFFFFFFF
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x2df39
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x24(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
xorl %esi, %esi
callq 0x2de70
movl %eax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x24(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movl $0xffffffff, 0x20(%rax) # imm = 0xFFFFFFFF
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x28(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x2e051
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rax
cmpl $-0x1, 0x1c(%rax)
jne 0x2e01f
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movl 0x10(%rsp), %esi
addl $0x1, %esi
callq 0x2de70
movl %eax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movl $0xffffffff, 0x20(%rax) # imm = 0xFFFFFFFF
movl 0xc(%rsp), %edx
movq 0x18(%rsp), %rax
movq 0x28(%rsp), %rcx
movq 0x10(%rcx), %rcx
movslq 0xc(%rsp), %rsi
movq (%rcx,%rsi,8), %rcx
movslq 0x1c(%rcx), %rcx
movl %edx, (%rax,%rcx,4)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x2dfbb
movq 0x18(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x2e066
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/subtreeIsoUtils.c
// Function: markReachable
void markReachable(struct Vertex* a, int num) {

	a->visited = 1;

	for (struct VertexList* e=a->neighborhood; e!=NULL; e=e->next) {
		if ((e->flag == 0) && (e->endPoint->visited == 0)) {
			markReachable(e->endPoint, num);
		}
	}
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movq 0x10(%rsp), %rax
movl $0x1, 0x1c(%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x2e0d6
movq (%rsp), %rax
cmpl $0x0, 0x24(%rax)
jne 0x2e0c6
movq (%rsp), %rax
movq 0x18(%rax), %rax
cmpl $0x0, 0x1c(%rax)
jne 0x2e0c6
movq (%rsp), %rax
movq 0x18(%rax), %rdi
movl 0xc(%rsp), %esi
callq 0x2e070
jmp 0x2e0c8
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
jmp 0x2e096
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/subtreeIsomorphismSampling.c
// Function: shuffleNeighbors
struct VertexList** shuffleNeighbors(struct Vertex* v, int degV) {
	if (degV > 0) {
		struct VertexList** edgeArray = malloc(degV * sizeof(struct VertexList*));
		edgeArray[0] = v->neighborhood;
		for (int i=1; i < degV; ++i) {
			edgeArray[i] = edgeArray[i-1]->next;
		}
		shuffle(edgeArray, degV);
		return edgeArray;
	}
	return NULL;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movl %esi, 0x14(%rsp)
cmpl $0x0, 0x14(%rsp)
jle 0x2e17b
movslq 0x14(%rsp), %rdi
shlq $0x3, %rdi
callq 0x1170
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movl $0x1, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0x14(%rsp), %eax
jge 0x2e160
movq 0x8(%rsp), %rax
movl 0x4(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rdx
movq 0x8(%rsp), %rax
movslq 0x4(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x2e124
movq 0x8(%rsp), %rdi
movslq 0x14(%rsp), %rsi
callq 0x2b0b0
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x2e184
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/subtreeIsomorphismSampling.c
// Function: getUncoveredNeighborArray
struct VertexList** getUncoveredNeighborArray(struct Vertex* v, int* uncoveredDegree) {
	*uncoveredDegree = 0;
	for (struct VertexList* e=v->neighborhood; e!=NULL; e=e->next) {
		if (e->endPoint->visited == 0) {
			++(*uncoveredDegree);
		}
	}
	if (*uncoveredDegree > 0) {
		struct VertexList** edgeArray = malloc(*uncoveredDegree * sizeof(struct VertexList*));
		int i=0;
		for (struct VertexList* e=v->neighborhood; e!=NULL; e=e->next) {
			if (e->endPoint->visited == 0) {
				edgeArray[i] = e;
				++i;
			}
		}
		return edgeArray;
	} else {
		return NULL;
	}
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movl $0x0, (%rax)
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x2e1ec
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rax
cmpl $0x0, 0x1c(%rax)
jne 0x2e1da
movq 0x20(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x2e1dc
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
jmp 0x2e1b7
movq 0x20(%rsp), %rax
cmpl $0x0, (%rax)
jle 0x2e26f
movq 0x20(%rsp), %rax
movslq (%rax), %rdi
shlq $0x3, %rdi
callq 0x1170
movq %rax, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x2e263
movq (%rsp), %rax
movq 0x18(%rax), %rax
cmpl $0x0, 0x1c(%rax)
jne 0x2e253
movq (%rsp), %rdx
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x2e255
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
jmp 0x2e221
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
jmp 0x2e278
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/subtreeIsomorphismSampling.c
// Function: subtreeIsomorphismSampler
char subtreeIsomorphismSampler(struct Graph* g, struct Graph* h) {

	// we root h at a random vertex
	struct Vertex* currentRoot = h->vertices[rand() % h->n];
	// and select a random image vertex
	struct Vertex* rootImage = g->vertices[rand() % g->n];

	char foundIso = 0;
	if (labelCmp(currentRoot->label, rootImage->label) == 0) {
		// if the labels match, we map the root to the image
		currentRoot->visited = rootImage->number + 1;
		rootImage->visited = 1;
		// and try to embed the rest of the tree h into g accordingly
		foundIso = recursiveSubtreeIsomorphismSampler(currentRoot, g);

		// cleanup
		cleanupSubtreeIsomorphismSampler(h, g);
	}

	return foundIso;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, (%rsp)
callq 0x1220
movq 0x28(%rsp), %rcx
cltd
idivl (%rcx)
movq (%rsp), %rax
movslq %edx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
callq 0x1220
movq 0x30(%rsp), %rcx
cltd
idivl (%rcx)
movq 0x8(%rsp), %rax
movslq %edx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x18(%rsp)
movb $0x0, 0x17(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rdi
movq 0x18(%rsp), %rax
movq (%rax), %rsi
callq 0x2dcf0
cmpl $0x0, %eax
jne 0x2e364
movq 0x18(%rsp), %rax
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x1c(%rax)
movq 0x18(%rsp), %rax
movl $0x1, 0x1c(%rax)
movq 0x20(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x2e370
movb %al, 0x17(%rsp)
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x2e5c0
movb 0x17(%rsp), %al
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/subtreeIsomorphismSampling.c
// Function: cleanupSubtreeIsomorphismSampler
static void cleanupSubtreeIsomorphismSampler(struct Graph* h, struct Graph* g) {
	for (int v=0; v<h->n; ++v) {
		int image = h->vertices[v]->visited;
		h->vertices[v]->visited = 0;
		if (image) {
			g->vertices[image-1]->visited = 0;
		}
	}
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl $0x0, -0x14(%rsp)
movl -0x14(%rsp), %eax
movq -0x8(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x2e645
movq -0x8(%rsp), %rax
movq 0x10(%rax), %rax
movslq -0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movl 0x1c(%rax), %eax
movl %eax, -0x18(%rsp)
movq -0x8(%rsp), %rax
movq 0x10(%rax), %rax
movslq -0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movl $0x0, 0x1c(%rax)
cmpl $0x0, -0x18(%rsp)
je 0x2e636
movq -0x10(%rsp), %rax
movq 0x10(%rax), %rax
movl -0x18(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movl $0x0, 0x1c(%rax)
jmp 0x2e638
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0x2e5d2
retq
nopw %cs:(%rax,%rax)