LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r8, %rbx
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %r12
cmpq %rdx, %rsi
je 0x1b7e4
cmpl $0x0, 0x1c(%r15)
je 0x1b7e4
movq 0x18(%r12), %r13
movq %r14, %rdi
movq %rbx, %rsi
callq 0x87fa
movq %rax, 0x18(%r12)
movq %r13, 0x18(%rax)
movq 0x8(%r15), %r13
testq %r13, %r13
je 0x1b848
movq 0x8(%r14), %rbp
movq 0x10(%rbx), %rsi
movq %r13, %rdi
callq 0x7bc0
movq %r14, %rdi
movq %rax, %rsi
callq 0x88b9
movq 0x18(%r13), %rsi
movq %r12, %rdi
movq %r15, %rdx
movq %r14, %rcx
movq %rbx, %r8
callq 0x1b7a8
movq 0x10(%rbx), %rdi
movq 0x8(%r14), %rsi
callq 0x1438e
movq %rbp, 0x8(%r14)
addq $0x8, %rbp
decl 0x10(%r14)
cmoveq %r14, %rbp
movq $0x0, (%rbp)
movq 0x8(%r13), %r13
jmp 0x1b7e8
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %r9, %rbx
movq %r8, %rbp
movq %rcx, %r15
movl %edx, %r12d
movq %rdi, %r14
cmpq %rsi, %rdi
je 0x1b8e9
movl 0x1c(%r14), %edx
testl %edx, %edx
je 0x1b8e9
addl %r12d, %edx
movl 0x20(%r14), %ecx
leaq 0x5068(%rip), %rsi      # 0x2093c
movq %rbp, %rdi
xorl %eax, %eax
callq 0x1160
movq %r15, %rdi
movq %rbp, %rsi
callq 0x70ff
movq 0x8(%r14), %r13
testq %r13, %r13
movq %rbp, (%rsp)
je 0x1b95a
movq %r14, %rbp
movq 0x8(%r15), %r14
movq 0x10(%rbx), %rsi
movq %r13, %rdi
callq 0x7bc0
movq %r15, %rdi
movq %rax, %rsi
callq 0x88b9
movq 0x18(%r13), %rdi
movq %rbp, %rsi
movl %r12d, %edx
movq %r15, %rcx
movq (%rsp), %r8
movq %rbx, %r9
callq 0x1b89f
movq 0x10(%rbx), %rdi
movq 0x8(%r15), %rsi
callq 0x1438e
movq %r14, 0x8(%r15)
addq $0x8, %r14
decl 0x10(%r15)
cmoveq %r15, %r14
movq $0x0, (%r14)
movq 0x8(%r13), %r13
testq %r13, %r13
jne 0x1b8f9
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %r14
movq %rcx, %r15
movq %rsi, %r12
movq %rdi, %r13
movslq %edx, %rdi
callq 0x1190
movq %rax, %rbx
leaq 0x560d(%rip), %rsi      # 0x20fe9
xorl %ebp, %ebp
leaq 0x24(%rsp), %rdx
leaq 0xc(%rsp), %rcx
movq %r13, %rdi
xorl %eax, %eax
callq 0x1060
cmpl $0x2, %eax
jne 0x1ba63
movq %rbx, 0x10(%rsp)
movl 0xc(%rsp), %ecx
xorl %ebp, %ebp
testl %ecx, %ecx
jle 0x1ba55
xorl %ebx, %ebx
movq %r15, 0x18(%rsp)
movq 0x10(%rsp), %r15
movq %r13, %rdi
leaq 0x4f23(%rip), %rsi      # 0x2093f
leaq 0x20(%rsp), %rdx
xorl %eax, %eax
callq 0x1060
addl %eax, %ebp
movq %r13, %rdi
movq %r15, %rsi
movq %r14, %rdx
callq 0x71ec
movq %r12, %rdi
movq %rax, %rsi
movq 0x18(%rsp), %rdx
movq %r14, %rcx
callq 0x1af0f
incl %ebx
movl 0xc(%rsp), %ecx
cmpl %ecx, %ebx
jl 0x1ba12
cmpl %ecx, %ebp
jne 0x1ba7c
movq 0x10(%rsp), %rbx
movl $0x1, %ebp
movq %rbx, %rdi
callq 0x1030
movl %ebp, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x11575(%rip), %rax     # 0x2cff8
movq (%rax), %rdi
leaq 0x552d(%rip), %rsi      # 0x20fba
movl %ebp, %edx
xorl %eax, %eax
callq 0x1160
jmp 0x1ba59
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %r8, %r15
movq %rcx, %r12
movq %rdx, %rbp
movq %rdi, %r13
movslq %esi, %rdi
callq 0x1190
movq %rax, %rbx
leaq 0x550e(%rip), %rsi      # 0x20fe8
xorl %r14d, %r14d
movq %r13, %rdi
movq %rbp, %rdx
movq %r12, %rcx
xorl %eax, %eax
callq 0x1060
cmpl $-0x1, %eax
je 0x1bb7e
cmpl $0x2, %eax
jne 0x1bb98
movq %rbx, (%rsp)
movl (%r12), %ecx
testl %ecx, %ecx
jle 0x1bb6e
xorl %ebp, %ebp
xorl %ebx, %ebx
movq %r12, 0x18(%rsp)
xorl %r12d, %r12d
movq %r15, 0x10(%rsp)
movq (%rsp), %r15
movq %r13, %rdi
leaq 0x4e12(%rip), %rsi      # 0x2093c
leaq 0xc(%rsp), %rdx
leaq 0x24(%rsp), %rcx
xorl %eax, %eax
callq 0x1060
addl %eax, %ebp
movq %r13, %rdi
movq %r15, %rsi
movq 0x10(%rsp), %rdx
callq 0x71ec
movq %rax, %r14
movl 0xc(%rsp), %eax
movl %eax, 0x28(%r14)
movq %r12, 0x18(%r14)
incl %ebx
movq 0x18(%rsp), %rax
movl (%rax), %ecx
movq %r14, %r12
cmpl %ecx, %ebx
jl 0x1bb20
jmp 0x1bb73
xorl %r14d, %r14d
xorl %ebp, %ebp
leal (%rcx,%rcx), %eax
cmpl %eax, %ebp
jne 0x1bbb7
movq (%rsp), %rbx
movq %rbx, %rdi
callq 0x1030
movq %r14, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x11459(%rip), %rcx     # 0x2cff8
movq (%rcx), %rdi
leaq 0x5449(%rip), %rsi      # 0x20ff2
xorl %r14d, %r14d
movl %eax, %edx
xorl %eax, %eax
callq 0x1160
jmp 0x1bb7e
movq 0x1143a(%rip), %rax     # 0x2cff8
movq (%rax), %rdi
leaq 0x5460(%rip), %rsi      # 0x21028
movl %ebp, %edx
xorl %eax, %eax
callq 0x1160
jmp 0x1bb7a
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
movq 0x10(%rsi), %rdi
callq 0x145b2
movq %rax, %r12
movq %r15, %rdi
movq %rax, %rsi
movl $0x800, %edx            # imm = 0x800
movq %r14, %rcx
movq %rbx, %r8
callq 0x1b9b0
movq %r12, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movslq (%rdi), %r12
leaq (,%r12,4), %r15
movq %r15, %rdi
callq 0x1190
movq %rax, %r14
testq %r12, %r12
jle 0x1bc84
movq 0x10(%rbx), %r13
movq %r14, %rdi
movl $0xff, %esi
movq %r15, %rdx
callq 0x10d0
xorl %eax, %eax
movq (%r13,%rax,8), %rcx
movl $0xffffffff, 0x1c(%rcx) # imm = 0xFFFFFFFF
incq %rax
cmpq %rax, %r12
jne 0x1bc70
movq 0x10(%rbx), %rax
movslq %ebp, %r15
movq (%rax,%r15,8), %rdi
xorl %esi, %esi
callq 0x1bd03
movq 0x10(%rbx), %rax
movq (%rax,%r15,8), %rax
movl $0xffffffff, 0x20(%rax) # imm = 0xFFFFFFFF
cmpl $0x0, (%rbx)
jle 0x1bcf1
movq 0x11347(%rip), %r13     # 0x2cff8
leaq 0x539f(%rip), %r15      # 0x21057
xorl %r12d, %r12d
movq 0x10(%rbx), %rax
movq (%rax,%r12,8), %rax
movslq 0x1c(%rax), %rax
cmpq $-0x1, %rax
je 0x1bcde
movl %r12d, (%r14,%rax,4)
incq %r12
movslq (%rbx), %rax
cmpq %rax, %r12
jl 0x1bcbb
jmp 0x1bcf1
movq (%r13), %rdi
movq %r15, %rsi
movl %r12d, %edx
xorl %eax, %eax
callq 0x1160
jmp 0x1bcd1
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/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:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %eax
movq %rdi, %rbx
movl $0xfffffffe, 0x1c(%rdi) # imm = 0xFFFFFFFE
movq 0x8(%rdi), %r14
testq %r14, %r14
je 0x1bd3f
movq 0x18(%r14), %rdi
cmpl $-0x1, 0x1c(%rdi)
jne 0x1bd39
movl %eax, %esi
callq 0x1bd03
incl %eax
movl 0x18(%rbx), %ecx
movq 0x18(%r14), %rdx
movl %ecx, 0x20(%rdx)
movq 0x8(%r14), %r14
jmp 0x1bd17
movl %eax, 0x1c(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movslq (%rdi), %r12
testq %r12, %r12
jle 0x1be0e
movl %esi, %ebp
movq %rdi, %rbx
movq %r12, %r15
shlq $0x2, %r15
movq %r15, %rdi
callq 0x1190
movq %rax, %r14
movq 0x10(%rbx), %r13
movq %rax, %rdi
movl $0xff, %esi
movq %r15, %rdx
callq 0x10d0
xorl %eax, %eax
movq (%r13,%rax,8), %rcx
movl $0xffffffff, 0x1c(%rcx) # imm = 0xFFFFFFFF
incq %rax
cmpq %rax, %r12
jne 0x1bd8e
movq 0x10(%rbx), %rax
movslq %ebp, %r15
movq (%rax,%r15,8), %rdi
xorl %esi, %esi
callq 0x1bd03
movq 0x10(%rbx), %rcx
movq (%rcx,%r15,8), %rcx
movl $0xffffffff, 0x20(%rcx) # imm = 0xFFFFFFFF
cmpl $0x0, (%rbx)
jle 0x1be11
xorl %r15d, %r15d
movq 0x10(%rbx), %rcx
movq (%rcx,%r15,8), %rdi
cmpl $-0x1, 0x1c(%rdi)
jne 0x1bdf1
incl %eax
movl %eax, %esi
callq 0x1bd03
movq 0x10(%rbx), %rcx
movq (%rcx,%r15,8), %rcx
movl $0xffffffff, 0x20(%rcx) # imm = 0xFFFFFFFF
movq 0x10(%rbx), %rcx
movq (%rcx,%r15,8), %rcx
movslq 0x1c(%rcx), %rcx
movl %r15d, (%r14,%rcx,4)
incq %r15
movslq (%rbx), %rcx
cmpq %rcx, %r15
jl 0x1bdcb
jmp 0x1be11
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/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:
pushq %r14
pushq %rbx
pushq %rax
movl $0x1, 0x1c(%rdi)
movq 0x8(%rdi), %r14
testq %r14, %r14
je 0x1be5a
movl %esi, %ebx
cmpl $0x0, 0x24(%r14)
jne 0x1be51
movq 0x18(%r14), %rdi
cmpl $0x0, 0x1c(%rdi)
jne 0x1be51
movl %ebx, %esi
callq 0x1be23
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0x1be39
addq $0x8, %rsp
popq %rbx
popq %r14
retq
nop
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
testl %esi, %esi
jle 0x1beba
movl %esi, %ebp
movq %rdi, %r15
movl %esi, %r14d
leaq (,%r14,8), %rdi
callq 0x1190
movq %rax, %rbx
movq 0x8(%r15), %rax
movq %rax, (%rbx)
cmpl $0x1, %ebp
je 0x1bead
movl $0x1, %eax
movq -0x8(%rbx,%rax,8), %rcx
movq 0x8(%rcx), %rcx
movq %rcx, (%rbx,%rax,8)
incq %rax
cmpq %rax, %r14
jne 0x1be98
movq %rbx, %rdi
movq %r14, %rsi
callq 0x1a427
jmp 0x1bebc
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %rbx
movq %rdi, %rbx
movl $0x0, (%rsi)
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x1beef
movq 0x18(%rax), %rcx
cmpl $0x0, 0x1c(%rcx)
jne 0x1bee9
incl (%rsi)
movq 0x8(%rax), %rax
jmp 0x1bed8
movslq (%rsi), %rdi
testq %rdi, %rdi
jle 0x1bf29
shlq $0x3, %rdi
callq 0x1190
movq 0x8(%rbx), %rcx
testq %rcx, %rcx
je 0x1bf2b
xorl %edx, %edx
movq 0x18(%rcx), %rsi
cmpl $0x0, 0x1c(%rsi)
jne 0x1bf1e
movslq %edx, %rdx
movq %rcx, (%rax,%rdx,8)
incl %edx
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
jne 0x1bf0b
jmp 0x1bf2b
xorl %eax, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %r15
callq 0x1250
cltd
idivl (%r14)
movslq %edx, %rax
movq (%r15,%rax,8), %r15
movq 0x10(%rbx), %r12
callq 0x1250
cltd
idivl (%rbx)
movslq %edx, %rax
movq (%r12,%rax,8), %r12
movq (%r15), %rdi
movq (%r12), %rsi
callq 0x1bc18
testl %eax, %eax
je 0x1bf79
xorl %eax, %eax
jmp 0x1bfd3
movl 0x18(%r12), %eax
incl %eax
movl %eax, 0x1c(%r15)
movl $0x1, 0x1c(%r12)
movq %r15, %rdi
movq %rbx, %rsi
callq 0x1bfdf
movslq (%r14), %rcx
testq %rcx, %rcx
jle 0x1bfd3
movq 0x10(%r14), %rdx
xorl %esi, %esi
movq (%rdx,%rsi,8), %r8
movslq 0x1c(%r8), %rdi
movl $0x0, 0x1c(%r8)
testq %rdi, %rdi
je 0x1bfcb
movq 0x10(%rbx), %r8
movq -0x8(%r8,%rdi,8), %rdi
movl $0x0, 0x1c(%rdi)
incq %rsi
cmpq %rsi, %rcx
jne 0x1bfa6
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/subtreeIsomorphismSampling.c
// Function: subtreeIsomorphismSamplerWithProperMatching
char subtreeIsomorphismSamplerWithProperMatching(struct Graph* g, struct Graph* h, struct GraphPool* gp) {

	// 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];
	//	fprintf(stderr, "\nnew round: %i -> %i\n", currentRoot->number, rootEmbedding->number);

	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 = recursiveSubtreeIsomorphismSamplerWithMatching(currentRoot, g, gp);

		// cleanup
		cleanupSubtreeIsomorphismSampler(h, g);
	}

	return foundIso;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdx, %r15
movq %rsi, %r14
movq %rdi, %rbx
movq 0x10(%rsi), %r12
callq 0x1250
cltd
idivl (%r14)
movslq %edx, %rax
movq (%r12,%rax,8), %r12
movq 0x10(%rbx), %r13
callq 0x1250
cltd
idivl (%rbx)
movslq %edx, %rax
movq (%r13,%rax,8), %r13
movq (%r12), %rdi
movq (%r13), %rsi
callq 0x1bc18
testl %eax, %eax
je 0x1c426
xorl %eax, %eax
jmp 0x1c482
movl 0x18(%r13), %eax
incl %eax
movl %eax, 0x1c(%r12)
movl $0x1, 0x1c(%r13)
movq %r12, %rdi
movq %rbx, %rsi
movq %r15, %rdx
callq 0x1c48c
movslq (%r14), %rcx
testq %rcx, %rcx
jle 0x1c482
movq 0x10(%r14), %rdx
xorl %esi, %esi
movq (%rdx,%rsi,8), %r8
movslq 0x1c(%r8), %rdi
movl $0x0, 0x1c(%r8)
testq %rdi, %rdi
je 0x1c47a
movq 0x10(%rbx), %r8
movq -0x8(%r8,%rdi,8), %rdi
movl $0x0, 0x1c(%rdi)
incq %rsi
cmpq %rsi, %rcx
jne 0x1c455
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/subtreeIsomorphismSampling.c
// Function: subtreeIsomorphismSamplerWithSampledMaximumMatching
int subtreeIsomorphismSamplerWithSampledMaximumMatching(struct Graph* g, struct Graph* h, struct GraphPool* gp, int computeEstimate) {

	// we root h at a random vertex
	struct Vertex* currentRoot = h->vertices[rand() % h->n];
	// and select a random image vertex with suitable label (if one exists)
	int nRootImageCandidates;
	struct Vertex* rootImage = getSuitableImage(currentRoot, g, gp->listPool, &nRootImageCandidates);
	//	struct Vertex* rootImage = g->vertices[rand() % g->n];


	int foundIso = 0;
	if (rootImage) {
		//	if (labelCmp(currentRoot->label, rootImage->label) == 0) {
		// if there is a candidate image 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 = recursiveSubtreeIsomorphismSamplerWithSampledMaximumMatching(currentRoot, g, gp, computeEstimate);

		// cleanup
		cleanupSubtreeIsomorphismSampler(h, g);
	}

	if (computeEstimate) {
		return foundIso * nRootImageCandidates;
	} else {
		return foundIso;
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movl %ecx, 0xc(%rsp)
movq %rdx, %rbx
movq %rsi, %r12
movq %rdi, %r14
movq 0x10(%rsi), %r15
callq 0x1250
cltd
movq %r12, 0x10(%rsp)
idivl (%r12)
movslq %edx, %rax
movq (%r15,%rax,8), %r13
movq 0x18(%rbx), %rbp
cmpl $0x0, (%r14)
jle 0x1c7b0
xorl %r15d, %r15d
xorl %r12d, %r12d
xorl %ebx, %ebx
movq (%r13), %rdi
movq 0x10(%r14), %rax
movq (%rax,%r12,8), %rax
movq (%rax), %rsi
callq 0x1bc18
testl %eax, %eax
jne 0x1c7a3
movq %rbp, %rdi
callq 0x1432b
movq %rbx, 0x8(%rax)
movq 0x10(%r14), %rcx
movq (%rcx,%r12,8), %rcx
movq %rcx, 0x18(%rax)
incl %r15d
movq %rax, %rbx
incq %r12
movslq (%r14), %rax
cmpq %rax, %r12
jl 0x1c76d
jmp 0x1c7b5
xorl %r15d, %r15d
xorl %ebx, %ebx
xorl %eax, %eax
testl %r15d, %r15d
jle 0x1c7ea
callq 0x1250
cltd
idivl %r15d
movq %rbx, %rax
testl %edx, %edx
jle 0x1c7d7
movq %rbx, %rax
movq 0x8(%rax), %rax
decl %edx
jne 0x1c7cf
movq 0x18(%rax), %r12
movq %rbp, %rdi
movq %rbx, %rsi
callq 0x143f0
xorl %eax, %eax
jmp 0x1c7ed
xorl %r12d, %r12d
testq %r12, %r12
movl 0xc(%rsp), %ebx
je 0x1c856
movl 0x18(%r12), %eax
incl %eax
movl %eax, 0x1c(%r13)
movl $0x1, 0x1c(%r12)
movq %r13, %rdi
movq %r14, %rsi
movl %ebx, %edx
callq 0x1c877
movq 0x10(%rsp), %rcx
movslq (%rcx), %r8
testq %r8, %r8
jle 0x1c856
movq 0x10(%rcx), %rcx
xorl %edx, %edx
movq (%rcx,%rdx,8), %rdi
movslq 0x1c(%rdi), %rsi
movl $0x0, 0x1c(%rdi)
testq %rsi, %rsi
je 0x1c84e
movq 0x10(%r14), %rdi
movq -0x8(%rdi,%rsi,8), %rsi
movl $0x0, 0x1c(%rsi)
incq %rdx
cmpq %rdx, %r8
jne 0x1c82a
testl %ebx, %ebx
movl $0x1, %ecx
cmovel %ecx, %r15d
imull %eax, %r15d
movl %r15d, %eax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/subtreeIsomorphismSampling.c
// Function: compareLabeledNeighbors
static int compareLabeledNeighbors(const void* p1, const void* p2) {
	struct VertexList* e1 = *(struct VertexList**)p1;
	struct VertexList* e2 = *(struct VertexList**)p2;

	int cmp = labelCmp(e1->label, e2->label);
	if (cmp == 0) {
		return labelCmp(e1->endPoint->label, e2->endPoint->label);
	} else {
		return cmp;
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq (%rdi), %r14
movq (%rsi), %rbx
movq (%r14), %rdi
movq (%rbx), %rsi
callq 0x1bc18
testl %eax, %eax
je 0x1cd35
addq $0x8, %rsp
popq %rbx
popq %r14
retq
movq 0x18(%r14), %rax
movq (%rax), %rdi
movq 0x18(%rbx), %rax
movq (%rax), %rsi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1bc18
nop
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/supportSet.c
// Function: popSupportSetElement
struct SupportSetElement* popSupportSetElement(struct SupportSet* s) {
	struct SupportSetElement* e = s->first;
	if (s->first != NULL) {
		s->first = e->next;
		s->size -= e->data.foundIso;
	}
	return e;
}

// Assembly:
movq (%rdi), %rax
testq %rax, %rax
je 0x1ce52
movq 0x28(%rax), %rcx
movq %rcx, (%rdi)
movslq 0x20(%rax), %rcx
subq %rcx, 0x18(%rdi)
retq
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/supportSet.c
// Function: popSupportSetData
struct SubtreeIsoDataStore popSupportSetData(struct SupportSet *s) {
	struct SupportSetElement* e = popSupportSetElement(s);
	struct SubtreeIsoDataStore data = e->data;
	free(e);
	return data;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq (%rsi), %rdi
testq %rdi, %rdi
je 0x1ce6e
movq 0x28(%rdi), %rax
movq %rax, (%rsi)
movslq 0x20(%rdi), %rax
subq %rax, 0x18(%rsi)
movq 0x20(%rdi), %rax
movq %rax, 0x20(%rbx)
movups (%rdi), %xmm0
movups 0x10(%rdi), %xmm1
movups %xmm1, 0x10(%rbx)
movups %xmm0, (%rbx)
callq 0x1030
movq %rbx, %rax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/supportSet.c
// Function: printSupportSet
void printSupportSet(struct SupportSet* l, FILE* out) {
	fprintf(out, "%zu elements: [", l->size);
	for (struct SupportSetElement* i=l->first; i!=NULL; i=i->next) {
		fprintf(out, "%i, ", i->data.g->number);
	}
	fprintf(out, "]\n");

}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %rdx
leaq 0x3537(%rip), %rsi      # 0x203db
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1160
movq (%r14), %r15
testq %r15, %r15
je 0x1ceda
leaq 0x352e(%rip), %r14      # 0x203eb
movq 0x8(%r15), %rax
movl 0x8(%rax), %edx
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x1160
movq 0x28(%r15), %r15
testq %r15, %r15
jne 0x1cebd
leaq 0x318f(%rip), %rdi      # 0x20070
movl $0x2, %esi
movl $0x1, %edx
movq %rbx, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x1220
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/supportSet.c
// Function: printSupportSetSparse
void printSupportSetSparse(struct SupportSet* l, FILE* out) {
	fprintf(out, "%i:", l->first->data.h->number);
	for (struct SupportSetElement* e=l->first; e!=NULL; e=e->next) {
		fprintf(out, " %i", e->data.g->number);
	}
	fprintf(out, "\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq (%rdi), %rax
movq 0x10(%rax), %rax
movl 0x8(%rax), %edx
leaq 0x34e2(%rip), %rsi      # 0x203f6
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1160
movq (%r14), %r15
testq %r15, %r15
je 0x1cf4a
leaq 0x467c(%rip), %r14      # 0x215a9
movq 0x8(%r15), %rax
movl 0x8(%rax), %edx
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x1160
movq 0x28(%r15), %r15
testq %r15, %r15
jne 0x1cf2d
movl $0xa, %edi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x1110
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/supportSet.c
// Function: dumpSupportSetElements
void dumpSupportSetElements(struct SupportSetElement* e) {
	if (e->next != NULL) {
		dumpSupportSetElements(e->next);
	}

	dumpNewCube(e->data.S, e->data.g->n);
	free(e);
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
testq %rdi, %rdi
je 0x1cfdf
callq 0x1cfcd
movq 0x8(%rbx), %rax
movq 0x18(%rbx), %rdi
movl (%rax), %esi
callq 0x1631f
movq %rbx, %rdi
popq %rbx
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/supportSet.c
// Function: dumpSupportSetElementsWithPostorder
void dumpSupportSetElementsWithPostorder(struct SupportSetElement* e, struct GraphPool* gp) {
	if (e->next != NULL) {
		dumpSupportSetElementsWithPostorder(e->next, gp);
	}

	dumpNewCube(e->data.S, e->data.g->n);
	dumpGraph(gp, e->data.h);
	free(e->data.postorder);
	free(e);
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %rbx
movq 0x28(%rdi), %rdi
testq %rdi, %rdi
je 0x1d02e
movq %r14, %rsi
callq 0x1d013
movq 0x8(%rbx), %rax
movq 0x18(%rbx), %rdi
movl (%rax), %esi
callq 0x1631f
movq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x14832
movq (%rbx), %rdi
callq 0x1030
movq %rbx, %rdi
addq $0x8, %rsp
popq %rbx
popq %r14
jmp 0x1030
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/supportSet.c
// Function: intersectTwoSupportSets
struct SupportSet* intersectTwoSupportSets(struct SupportSet* l1, struct SupportSet* l2) {
	struct SupportSet* supportList = getSupportSet();

	struct SupportSetElement* a = l1->first;
	struct SupportSetElement* b = l2->first;

	/* Once one or the other list runs out -- we're done */
	while (a != NULL && b != NULL)
	{
		if (a->data.g->number == b->data.g->number)
		{
			appendSupportSetData(supportList, a->data);
			a = a->next;
			b = b->next;
		}
		else if (a->data.g->number < b->data.g->number) /* advance the smaller list */
			a = a->next;
		else
			b = b->next;
	}
	return supportList;

}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movl $0x1, %edi
movl $0x28, %esi
callq 0x1120
movq %rax, %rbx
movq (%r15), %r15
movq (%r14), %r14
testq %r15, %r15
setne %al
testq %r14, %r14
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x1d158
movq %rbx, %r12
addq $0x8, %r12
movq 0x8(%r15), %rax
movq 0x8(%r14), %rcx
movl 0x8(%rcx), %ecx
cmpl %ecx, 0x8(%rax)
jne 0x1d142
movl $0x1, %edi
movl $0x30, %esi
callq 0x1120
movq 0x20(%r15), %rcx
movups (%r15), %xmm0
movups 0x10(%r15), %xmm1
movups %xmm0, (%rax)
movups %xmm1, 0x10(%rax)
movq %rcx, 0x20(%rax)
movq 0x8(%rbx), %rcx
leaq 0x28(%rcx), %rdx
xorl %esi, %esi
testq %rcx, %rcx
setne %sil
cmoveq %r12, %rdx
movq %rax, (%rdx)
movq %rax, (%rbx,%rsi,8)
movslq 0x20(%rax), %rax
addq %rax, 0x18(%rbx)
movq 0x28(%r15), %r15
jmp 0x1d14a
jge 0x1d14a
movq 0x28(%r15), %r15
jmp 0x1d14e
movq 0x28(%r14), %r14
testq %r15, %r15
je 0x1d158
testq %r14, %r14
jne 0x1d0e1
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/supportSet.c
// Function: intersectSupportSets
struct SupportSet* intersectSupportSets(struct SupportSet* aprioriList) {
	if (aprioriList == NULL) {
		return NULL;
	}
	if (aprioriList->next == NULL) {
		return intersectTwoSupportSets(aprioriList, aprioriList); // copy
	}

	struct SupportSet* intersection = intersectTwoSupportSets(aprioriList, aprioriList->next);
	for (struct SupportSet* support=aprioriList->next->next; support!=NULL; support=support->next) {
		struct SupportSet* tmp = intersectTwoSupportSets(intersection, support);
		dumpSupportSetCopy(intersection);
		intersection = tmp;
	}

	return intersection;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
testq %rdi, %rdi
je 0x1d1b6
movq %rdi, %rbx
movq 0x10(%rdi), %rsi
testq %rsi, %rsi
je 0x1d1bb
callq 0x1d0a1
movq %rax, %r14
movq 0x10(%rbx), %rax
movq 0x10(%rax), %rbx
testq %rbx, %rbx
je 0x1d1c8
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1d0a1
movq %rax, %r15
movq %r14, %rdi
callq 0x1cfb1
movq 0x10(%rbx), %rbx
movq %r15, %r14
testq %rbx, %rbx
jne 0x1d192
jmp 0x1d1cb
xorl %r15d, %r15d
jmp 0x1d1cb
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x1d0a1
movq %r14, %r15
movq %r15, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/supportSet.c
// Function: isSortedSupportSetOnPatterns
char isSortedSupportSetOnPatterns(struct SupportSet* l) {
	if (l->size < 2) {
		return 1;
	}
	for (struct SupportSet* e=l; e->next!=NULL; e=e->next) {
		if (e->first->data.h->number >= e->next->first->data.h->number) {
			return 0;
		}
	}
	return 1;
}

// Assembly:
movb $0x1, %al
cmpq $0x2, 0x18(%rdi)
jb 0x1d205
movq 0x10(%rdi), %rax
testq %rax, %rax
je 0x1d1ff
movq (%rdi), %rcx
movq 0x10(%rcx), %rcx
movl 0x8(%rcx), %ecx
movq (%rax), %rdx
movq 0x10(%rdx), %rdx
movq %rax, %rdi
cmpl 0x8(%rdx), %ecx
jl 0x1d1dd
testq %rax, %rax
sete %al
retq
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/supportSet.c
// Function: getSupportSetsOfPatterns
struct SupportSet* getSupportSetsOfPatterns(struct SupportSet* allSupportSets, struct IntSet* patternIds) {
	assert(allSupportSets != NULL);
	assert(patternIds != NULL);
	assert(isSortedUniqueIntSet(patternIds));
	assert(isSortedSupportSetOnPatterns(allSupportSets));

	struct SupportSet* selectedSupportSets = NULL;

	struct SupportSet* a = allSupportSets;
	struct IntElement* b = patternIds->first;

	size_t assert_Found = 0;

	/* Once one or the other list runs out -- we're done */
	while (a != NULL && b != NULL)
	{
		if (a->first->data.h->number == b->value) {
			struct SupportSet* supportSet = shallowCopySupportSet(a);
			supportSet->next = selectedSupportSets;
			selectedSupportSets = supportSet;

			a = a->next;
			b = b->next;

			++assert_Found;
		}
		else if (a->first->data.h->number < b->value) /* advance the smaller list */
			a = a->next;
		else
			b = b->next;
	}

	assert(assert_Found == patternIds->size);
	return selectedSupportSets;

}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq (%rsi), %r15
testq %rdi, %rdi
setne %al
testq %r15, %r15
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x1d28b
movq %rdi, %rbx
xorl %r14d, %r14d
movq (%rbx), %r12
movq 0x10(%r12), %rax
movl (%r15), %ecx
cmpl %ecx, 0x8(%rax)
jne 0x1d273
movl $0x1, %edi
movl $0x28, %esi
callq 0x1120
movq %r12, (%rax)
movq 0x8(%rbx), %rcx
movq %rcx, 0x8(%rax)
movl 0x20(%rbx), %ecx
movl %ecx, 0x20(%rax)
movq 0x18(%rbx), %rcx
movq %rcx, 0x18(%rax)
movq %r14, 0x10(%rax)
movq 0x10(%rbx), %rbx
movq 0x8(%r15), %r15
movq %rax, %r14
jmp 0x1d27f
jge 0x1d27b
movq 0x10(%rbx), %rbx
jmp 0x1d27f
movq 0x8(%r15), %r15
testq %rbx, %rbx
je 0x1d28e
testq %r15, %r15
jne 0x1d22a
jmp 0x1d28e
xorl %r14d, %r14d
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/supportSet.c
// Function: shallowCopySupportSet
struct SupportSet* shallowCopySupportSet(struct SupportSet* a) {
	struct SupportSet* copy = getSupportSet();
	copy->first = a->first;
	copy->last = a->last;
	copy->patternId = a->patternId;
	copy->size = a->size;
	return copy;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl $0x1, %edi
movl $0x28, %esi
callq 0x1120
movups (%rbx), %xmm0
movups %xmm0, (%rax)
movl 0x20(%rbx), %ecx
movl %ecx, 0x20(%rax)
movq 0x18(%rbx), %rcx
movq %rcx, 0x18(%rax)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/supportSet.c
// Function: appendSupportSets
struct SupportSet* appendSupportSets(struct SupportSet* front, struct SupportSet* back) {
	struct SupportSet* tmp; 
	if (front) {
		for (tmp=front; tmp->next != NULL; tmp=tmp->next);
		tmp->next = back;
	} else {
		front = back;
	}
	return front;
}

// Assembly:
testq %rdi, %rdi
je 0x1d31a
movq %rdi, %rax
movq %rdi, %rdx
movq %rdx, %rcx
movq 0x10(%rdx), %rdx
testq %rdx, %rdx
jne 0x1d309
movq %rsi, 0x10(%rcx)
retq
movq %rsi, %rax
retq
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/supportSet.c
// Function: popSupportSet
struct SupportSet* popSupportSet(struct SupportSet** s) {
	struct SupportSet* head = (*s);
	(*s) = (*s)->next;
	head->next = NULL;
	return head;
}

// Assembly:
movq (%rdi), %rax
movq 0x10(%rax), %rcx
movq %rcx, (%rdi)
movq $0x0, 0x10(%rax)
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/treeCenter.c
// Function: _markEdges
int __markEdges(struct Vertex* root, int value) {
	struct VertexList* e;
	int max = value;

	root->lowPoint = value;

	for (e=root->neighborhood; e!=NULL; e=e->next) {
		if (e->endPoint->lowPoint > value) {
			/* __markEdges returns the depth of the subtree rooted at 
			e->endPoint */
			int current = __markEdges(e->endPoint, value + 1);
			e->used = current;

			if (current > max) {
				max = current;
			}
		}
	}
	/* return the maximum depth of any subtree rooted at root */
	return max;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movl %esi, 0x20(%rdi)
movq 0x8(%rdi), %r15
testq %r15, %r15
je 0x1d374
leal 0x1(%rbx), %r14d
movl %ebx, %ebp
movq 0x18(%r15), %rdi
cmpl %ebx, 0x20(%rdi)
jle 0x1d369
movl %r14d, %esi
callq 0x1d334
movl %eax, 0x20(%r15)
cmpl %ebp, %eax
cmovgl %eax, %ebp
movq 0x8(%r15), %r15
testq %r15, %r15
jne 0x1d34f
jmp 0x1d376
movl %ebx, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/treeCenter.c
// Function: _moveCenter
void __moveCenter(struct Vertex* root, struct Vertex* parent, int value, int depth, int* centers) {
	struct VertexList* e;
	int max = INT_MIN;
	struct VertexList* max1 = NULL;
	struct VertexList* max2 = NULL;

	/* update depths to fit to the new root */
	for (e=root->neighborhood; e!=NULL; e=e->next) {
		if (e->endPoint != parent) {
			e->used -= depth;
		} else {
			e->used = value;
		}
	}

	/* find maximum depth branch */
	for (e=root->neighborhood; e!=NULL; e=e->next) {
		if (e->used > max) {
			max = e->used;
			max1 = e;
		}
	}

	/* find second maximum depth branch */
	max = INT_MIN;
	for (e=root->neighborhood; e!=NULL; e=e->next) {
		if (e != max1) {
			if (e->used > max) {
				max = e->used;
				max2 = e;
			}
		}
	}

	/* if the current node is no leaf */
	if (max2 != NULL) {

		/* if the two deepest branches have same depth, we are at the 
		center */
		if (max1->used == max2->used) {
			centers[0] = 2;
			centers[1] = root->number;
			return;
		}

		/* this is the case where the longest path has odd length
		and we get two center nodes */
		if (max1->used == max2->used + 1) {
			centers[0] = 3;
			centers[1] = root->number;
			centers[2] = max1->endPoint->number;
			return;
		}
		/* ...and the symmetric case */
		if (max2->used == max1->used + 1) {
			centers[0] = 3;
			centers[1] = root->number;
			centers[2] = max2->endPoint->number;
			return;
		}

		/* move the center to the root of the deepest branch */
		__moveCenter(max1->endPoint, root, max2->used + 1, depth + 1, centers);
	} else {
		/* if we start at a leaf */
		__moveCenter(max1->endPoint, root, 1, 1, centers);
	}	
}

// Assembly:
movq %rdi, %rax
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x1d3a5
movl %edx, %r9d
cmpq %rsi, 0x18(%rdi)
je 0x1d39f
movl 0x20(%rdi), %r9d
subl %ecx, %r9d
movl %r9d, 0x20(%rdi)
jmp 0x1d386
movq 0x8(%rax), %rdx
testq %rdx, %rdx
je 0x1d3cf
movl $0x80000000, %edi       # imm = 0x80000000
xorl %esi, %esi
movl 0x20(%rdx), %r9d
cmpl %edi, %r9d
cmovgl %r9d, %edi
cmovgq %rdx, %rsi
movq 0x8(%rdx), %rdx
testq %rdx, %rdx
jne 0x1d3b5
jmp 0x1d3d1
xorl %esi, %esi
movq 0x8(%rax), %rdx
testq %rdx, %rdx
je 0x1d401
movl $0x80000000, %r9d       # imm = 0x80000000
xorl %edi, %edi
cmpq %rsi, %rdx
je 0x1d3f6
movl 0x20(%rdx), %r10d
cmpl %r9d, %r10d
cmovgl %r10d, %r9d
cmovgq %rdx, %rdi
movq 0x8(%rdx), %rdx
testq %rdx, %rdx
jne 0x1d3e2
jmp 0x1d403
xorl %edi, %edi
testq %rdi, %rdi
je 0x1d434
movl 0x20(%rsi), %r9d
movl 0x20(%rdi), %r10d
cmpl %r10d, %r9d
je 0x1d44a
leal 0x1(%r10), %edx
cmpl %edx, %r9d
je 0x1d459
incl %r9d
cmpl %r9d, %r10d
je 0x1d46d
movq 0x18(%rsi), %rdi
incl %ecx
movq %rax, %rsi
jmp 0x1d383
movq 0x18(%rsi), %rdi
movl $0x1, %edx
movq %rax, %rsi
movl $0x1, %ecx
jmp 0x1d383
movl $0x2, (%r8)
movl 0x18(%rax), %eax
movl %eax, 0x4(%r8)
retq
movl $0x3, (%r8)
movl 0x18(%rax), %eax
movl %eax, 0x4(%r8)
movq 0x18(%rsi), %rax
jmp 0x1d47f
movl $0x3, (%r8)
movl 0x18(%rax), %eax
movl %eax, 0x4(%r8)
movq 0x18(%rdi), %rax
movl 0x18(%rax), %eax
movl %eax, 0x8(%r8)
retq
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/treeCenter.c
// Function: treeCenter
int* treeCenter(struct Graph* tree) {
	int* centers = malloc(3 * sizeof(int));
	int i;

	if (tree->n < 3) {
		/* if the tree consists of one or two vertices, the
		center is clear (and the root-rebase algorithm does not work)
		*/
		if (tree->n == 1) {
			centers[0] = 2;
			centers[1] = 0;
		} else {
			centers[0] = 3;
			centers[1] = 0;
			centers[2] = 1;
		} /* zero vertex trees are not allowed */
	} else {
		/* init lowpoints and do the root-rebase algorithm
		starting from the first vertex we can get a hold of */
		for (i=0; i<tree->n; ++i) {
			tree->vertices[i]->lowPoint = INT_MAX;
		}
		__markEdges(tree->vertices[0], 0);
		__moveCenter(tree->vertices[0], tree->vertices[0] /*NULL*/, 0, 0, centers);	
	}
	return centers;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %r14
movl $0xc, %edi
callq 0x1190
movq %rax, %rbx
movslq (%r14), %rax
cmpq $0x3, %rax
jge 0x1d4b2
cmpl $0x1, %eax
jne 0x1d4f1
movq $0x2, (%rbx)
jmp 0x1d4ff
movq 0x10(%r14), %rcx
xorl %edx, %edx
movq (%rcx,%rdx,8), %rsi
movl $0x7fffffff, 0x20(%rsi) # imm = 0x7FFFFFFF
incq %rdx
cmpq %rdx, %rax
jne 0x1d4b8
movq 0x10(%r14), %rax
movq (%rax), %rdi
xorl %esi, %esi
callq 0x1d334
movq 0x10(%r14), %rax
movq (%rax), %rdi
movq %rdi, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
movq %rbx, %r8
callq 0x1d383
jmp 0x1d4ff
movq $0x3, (%rbx)
movl $0x1, 0x8(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/treeCenter.c
// Function: computeDistanceToCenter
int computeDistanceToCenter(struct Graph* g, struct ShallowGraphPool* sgp) {

	struct ShallowGraph* queue = getShallowGraph(sgp);

	// copmute tree center
	int* center = treeCenter(g);

	// clean the ->lowpoints
	for (int v=0; v<g->n; ++v) {
		g->vertices[v]->lowPoint = -1;
	}

	// init the queue with (bi)center
	for (int i=1; i<center[0]; ++i) {
		addToVertexQueue(g->vertices[center[i]], queue, sgp);
		g->vertices[center[i]]->lowPoint = 0;
	}
	free(center);

	// do bfs, mark vertices according to their distance to the (bi)center
	int depth = 0;
	for (struct Vertex* v=popFromVertexQueue(queue, sgp); v!=NULL; v=popFromVertexQueue(queue, sgp)) {
		depth = v->lowPoint + 1;
		for (struct VertexList* e=v->neighborhood; e!=NULL; e=e->next) {
			if (e->endPoint->lowPoint == -1) {
				e->endPoint->lowPoint = depth;
				addToVertexQueue(e->endPoint, queue, sgp);
			}
		}
	}
	dumpShallowGraph(sgp, queue);

	// depth is set too high by the last loop over the leaves in the outer shell
	return depth - 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
movq %rsi, %rdi
callq 0x14aae
movq %rax, %r14
movq %r15, %rdi
callq 0x1d487
movq %rax, %r12
movslq (%r15), %rax
testq %rax, %rax
jle 0x1d552
movq 0x10(%r15), %rcx
xorl %edx, %edx
movq (%rcx,%rdx,8), %rsi
movl $0xffffffff, 0x20(%rsi) # imm = 0xFFFFFFFF
incq %rdx
cmpq %rdx, %rax
jne 0x1d53f
cmpl $0x2, (%r12)
jl 0x1d595
movl $0x1, %r13d
movq 0x10(%r15), %rax
movslq (%r12,%r13,4), %rcx
movq (%rax,%rcx,8), %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1e8ac
movq 0x10(%r15), %rax
movslq (%r12,%r13,4), %rcx
movq (%rax,%rcx,8), %rax
movl $0x0, 0x20(%rax)
incq %r13
movslq (%r12), %rax
cmpq %rax, %r13
jl 0x1d55f
movq %r12, %rdi
callq 0x1030
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1e8d5
testq %rax, %rax
je 0x1d5f3
movl 0x20(%rax), %r15d
movq 0x8(%rax), %r12
testq %r12, %r12
je 0x1d5e1
leal 0x1(%r15), %ebp
movq 0x18(%r12), %rdi
cmpl $-0x1, 0x20(%rdi)
jne 0x1d5d7
movl %ebp, 0x20(%rdi)
movq %r14, %rsi
movq %rbx, %rdx
callq 0x1e8ac
movq 0x8(%r12), %r12
testq %r12, %r12
jne 0x1d5be
movq %r14, %rdi
movq %rbx, %rsi
callq 0x1e8d5
testq %rax, %rax
jne 0x1d5ad
jmp 0x1d5f9
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
movq %rbx, %rdi
movq %r14, %rsi
callq 0x14b19
movl %r15d, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/treeEnumeration.c
// Function: refinementGraph
struct Graph* refinementGraph(struct Graph* g, int v, struct VertexList* newEdge, struct GraphPool* gp) {
	struct Graph* copy = getGraph(gp);
	int i;

	copy->activity = g->activity;
	copy->m = g->m; // addEdgebetweenVertices adds plus 1 itself
	copy->n = g->n + 1;
	copy->number = g->number;

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

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

	/* copy new vertex and edge */
	copy->vertices[copy->n - 1] = shallowCopyVertex(newEdge->endPoint, gp->vertexPool);
	copy->vertices[copy->n - 1]->number = copy->n - 1;
	addEdgeBetweenVertices(v, copy->n - 1, newEdge->label, copy, gp);

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

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

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r12
movl %esi, %ebp
movq %rdi, %r14
movq %rcx, %rdi
callq 0x147d7
movq %rax, %r15
movl 0xc(%r14), %eax
movl %eax, 0xc(%r15)
movslq (%r14), %rax
leaq 0x1(%rax), %rcx
movl %ecx, (%r15)
movq 0x4(%r14), %rcx
movq %rcx, 0x4(%r15)
leaq 0x8(,%rax,8), %rdi
callq 0x1190
movq %rax, 0x10(%r15)
cmpl $0x0, (%r14)
jle 0x1d696
xorl %r13d, %r13d
movq 0x10(%r14), %rax
movq (%rax,%r13,8), %rdi
testq %rdi, %rdi
je 0x1d68b
movq 0x10(%rbx), %rsi
callq 0x7c08
movq 0x10(%r15), %rcx
movq %rax, (%rcx,%r13,8)
incq %r13
movslq (%r14), %rax
cmpq %rax, %r13
jl 0x1d66d
movq 0x18(%r12), %rdi
movq 0x10(%rbx), %rsi
callq 0x7c08
movq 0x10(%r15), %rcx
movslq (%r15), %rsi
movq %rax, -0x8(%rcx,%rsi,8)
movq 0x10(%r15), %rax
movq -0x8(%rax,%rsi,8), %rax
decq %rsi
movl %esi, 0x18(%rax)
movq (%r12), %rdx
movl %ebp, %edi
movq %r15, %rcx
movq %rbx, %r8
callq 0x8425
cmpl $0x0, (%r14)
jle 0x1d750
xorl %r12d, %r12d
movq 0x10(%r14), %rax
movq (%rax,%r12,8), %rax
testq %rax, %rax
je 0x1d745
movq 0x8(%rax), %r13
testq %r13, %r13
je 0x1d745
movq 0x18(%rbx), %rdi
callq 0x1432b
movq 0x10(%r15), %rcx
movq 0x18(%r13), %rdx
movslq 0x18(%rdx), %rdx
movq (%rcx,%rdx,8), %rdx
movq %rdx, 0x18(%rax)
movq 0x10(%r13), %rdx
movslq 0x18(%rdx), %rdx
movq (%rcx,%rdx,8), %rdx
movq %rdx, 0x10(%rax)
movq (%r13), %rdx
movq %rdx, (%rax)
movq 0x10(%r13), %rdx
movslq 0x18(%rdx), %rdx
movq (%rcx,%rdx,8), %rsi
movq 0x8(%rsi), %rsi
movq %rsi, 0x8(%rax)
movq (%rcx,%rdx,8), %rcx
movq %rax, 0x8(%rcx)
movq 0x8(%r13), %r13
jmp 0x1d6ea
incq %r12
movslq (%r14), %rax
cmpq %rax, %r12
jl 0x1d6d9
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/treeEnumeration.c
// Function: extendPatternAllWays
struct Graph* extendPatternAllWays(struct Graph* g, struct ShallowGraph* candidateEdges, struct GraphPool* gp) {
	struct Graph* rho = NULL;
	struct VertexList* e;
	for (e=candidateEdges->edges; e!=NULL; e=e->next) {
		int v;
		for (v=0; v<g->n; ++v) {
			/* if the labels are compatible */
			if (strcmp(g->vertices[v]->label, e->startPoint->label) == 0) {
				struct Graph* h = refinementGraph(g, v, e, gp);
				h->next = rho;
				rho = h;
			}
		}
	}
	return rho;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq (%rsi), %r12
testq %r12, %r12
je 0x1d7d0
movq %rdx, %rbx
movq %rdi, %r14
xorl %r15d, %r15d
cmpl $0x0, (%r14)
jle 0x1d7c4
xorl %r13d, %r13d
movq 0x10(%r14), %rax
movq (%rax,%r13,8), %rax
movq (%rax), %rdi
movq 0x10(%r12), %rax
movq (%rax), %rsi
callq 0x1140
testl %eax, %eax
jne 0x1d7b9
movq %r14, %rdi
movl %r13d, %esi
movq %r12, %rdx
movq %rbx, %rcx
callq 0x1d618
movq %r15, 0x18(%rax)
movq %rax, %r15
incq %r13
movslq (%r14), %rax
cmpq %rax, %r13
jl 0x1d785
movq 0x8(%r12), %r12
testq %r12, %r12
jne 0x1d77c
jmp 0x1d7d3
xorl %r15d, %r15d
movq %r15, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq