LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/graphPrinting.c
// Function: printDirectedGraphDotFormat
void printDirectedGraphDotFormat(struct Graph* g, FILE* out) {
	fprintf(out, "digraph %i {\n", g->number);
	for (int v=0; v<g->n; ++v) {
		fprintf(out, "%i [label=%s];\n", v, g->vertices[v]->label);
	}
	for (int v=0; v<g->n; ++v) {
		for (struct VertexList* e=g->vertices[v]->neighborhood; e!=NULL; e=e->next) {
			fprintf(out, "%i -> %i [label=%s];\n", e->startPoint->number, e->endPoint->number, g->vertices[v]->label);
		}
	}
	fprintf(out, "}\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl 0x8(%rdi), %edx
leaq 0x16547(%rip), %rsi     # 0x1d39e
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1150
leaq 0x16563(%rip), %r15     # 0x1d3cb
xorl %r12d, %r12d
movslq (%r14), %rax
cmpq %rax, %r12
jge 0x6e93
movq 0x10(%r14), %rax
movq (%rax,%r12,8), %rax
movq (%rax), %rcx
movq %rbx, %rdi
movq %r15, %rsi
movl %r12d, %edx
xorl %eax, %eax
callq 0x1150
incq %r12
jmp 0x6e6b
leaq 0x16512(%rip), %r15     # 0x1d3ac
xorl %r12d, %r12d
cltq
cmpq %rax, %r12
jge 0x6ee5
movq 0x10(%r14), %rax
movq (%rax,%r12,8), %r13
movq 0x8(%r13), %r13
testq %r13, %r13
je 0x6edd
movq 0x10(%r13), %rax
movq 0x18(%r13), %rcx
movl 0x18(%rax), %edx
movl 0x18(%rcx), %ecx
movq 0x10(%r14), %rax
movq (%rax,%r12,8), %rax
movq (%rax), %r8
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x1150
jmp 0x6eac
incq %r12
movl (%r14), %eax
jmp 0x6e9d
leaq 0x164d6(%rip), %rdi     # 0x1d3c2
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1210
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/graphPrinting.c
// Function: printGraphDotFormat
void printGraphDotFormat(struct Graph* g, FILE* out) {
	fprintf(out, "graph %i {\n", g->number);
	for (int v=0; v<g->n; ++v) {
		fprintf(out, "%i [label=%s];\n", v, g->vertices[v]->label);
	}
	for (int v=0; v<g->n; ++v) {
		for (struct VertexList* e=g->vertices[v]->neighborhood; e!=NULL; e=e->next) {
			if (e->startPoint->number < e->endPoint->number) {
				fprintf(out, "%i -- %i [label=%s];\n", e->startPoint->number, e->endPoint->number, g->vertices[v]->label);
			}
		}
	}
	fprintf(out, "}\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movl 0x8(%rdi), %edx
leaq 0x16484(%rip), %rsi     # 0x1d3a0
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1150
leaq 0x1649e(%rip), %r15     # 0x1d3cb
xorl %r12d, %r12d
movslq (%r14), %rax
cmpq %rax, %r12
jge 0x6f58
movq 0x10(%r14), %rax
movq (%rax,%r12,8), %rax
movq (%rax), %rcx
movq %rbx, %rdi
movq %r15, %rsi
movl %r12d, %edx
xorl %eax, %eax
callq 0x1150
incq %r12
jmp 0x6f30
leaq 0x16466(%rip), %r15     # 0x1d3c5
xorl %r12d, %r12d
cltq
cmpq %rax, %r12
jge 0x6fae
movq 0x10(%r14), %rax
movq (%rax,%r12,8), %r13
movq 0x8(%r13), %r13
testq %r13, %r13
je 0x6fa6
movq 0x10(%r13), %rax
movq 0x18(%r13), %rcx
movl 0x18(%rax), %edx
movl 0x18(%rcx), %ecx
cmpl %ecx, %edx
jge 0x6f71
movq 0x10(%r14), %rax
movq (%rax,%r12,8), %rax
movq (%rax), %r8
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x1150
jmp 0x6f71
incq %r12
movl (%r14), %eax
jmp 0x6f62
leaq 0x1640d(%rip), %rdi     # 0x1d3c2
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1210
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/hp_cactus.c
// Function: isWeaklyTraceableUnsafe
char isWeaklyTraceableUnsafe(struct Graph* g, struct ShallowGraphPool* sgp) {
	struct ShallowGraph* biconnectedComponents = listBiconnectedComponents(g, sgp);
	int* criticality = computeCriticality(biconnectedComponents, g->n);
	int v; 
	struct ShallowGraph* c;

	// test if every vertex has criticality at most 2
	for (v=0; v<g->n; ++v) {
		if (criticality[v] > 2) {
			free(criticality);
			dumpShallowGraphCycle(sgp, biconnectedComponents);
			return 0;
		}
	}

	// test if every biconnected component contains at most two critical vertices.
	for (c=biconnectedComponents; c!=NULL; c=c->next) {
		struct VertexList* e;
		int criticalVertexCount = 0;

		// TODO measure if the alg is faster with or without this line
		if (c->m == 1) continue;

		// init ->visited = 0
		for (e=c->edges; e!=NULL; e=e->next) {
			e->startPoint->visited = 0;
			e->endPoint->visited = 0;
		}
		// count critical vertices
		for (e=c->edges; e!=NULL; e=e->next) {
			criticalVertexCount += visit(e->startPoint, criticality);
			criticalVertexCount += visit(e->endPoint, criticality);
		}
		if (criticalVertexCount > 2) {
			free(criticality);
			dumpShallowGraphCycle(sgp, biconnectedComponents);
			return 0;
		 } else {
			/* this is where misclassification might occur.
			we would need to check, if there is a Hamiltonian path in the biconnected
			component starting at one critical vertex and stopping at the other, if 
			there is a Hamiltonian path starting at the single critical vertex, or if there 
			is no critical vertex, if the biconnected block is traceable in any way. */
		}
	}

	// otherwise, there might exist a Hamiltonian path
	return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
callq 0x8ccd
movq %rax, %r14
movl (%r15), %esi
movq %rax, %rdi
callq 0x8b10
movl (%r15), %ecx
xorl %edx, %edx
testl %ecx, %ecx
cmovlel %edx, %ecx
cmpq %rdx, %rcx
je 0x7191
cmpl $0x3, (%rax,%rdx,4)
leaq 0x1(%rdx), %rdx
jl 0x7168
movq %rax, %rdi
callq 0x1030
movq %rbx, %rdi
movq %r14, %rsi
callq 0x11888
xorl %eax, %eax
jmp 0x7243
pushq $0x1
popq %rcx
movq %r14, %rdx
testq %rdx, %rdx
je 0x7241
cmpl $0x1, 0x10(%rdx)
je 0x7238
movq %rdx, %rsi
movq (%rsi), %rsi
testq %rsi, %rsi
je 0x71cb
movq 0x10(%rsi), %rdi
andl $0x0, 0x1c(%rdi)
movq 0x18(%rsi), %rdi
andl $0x0, 0x1c(%rdi)
addq $0x8, %rsi
jmp 0x71ad
xorl %edi, %edi
movq %rdx, %rsi
movq (%rsi), %rsi
testq %rsi, %rsi
je 0x722f
movq 0x10(%rsi), %r8
cmpl $0x0, 0x1c(%r8)
jne 0x71f9
movl $0x1, 0x1c(%r8)
movslq 0x18(%r8), %r8
cmpl $0x1, (%rax,%r8,4)
movl %ecx, %r8d
jg 0x71fc
xorl %r8d, %r8d
movq 0x18(%rsi), %r9
cmpl $0x0, 0x1c(%r9)
jne 0x721d
movl $0x1, 0x1c(%r9)
movslq 0x18(%r9), %r9
cmpl $0x1, (%rax,%r9,4)
movl %ecx, %r9d
jg 0x7220
xorl %r9d, %r9d
addl %edi, %r8d
addl %r9d, %r8d
addq $0x8, %rsi
movl %r8d, %edi
jmp 0x71d0
cmpl $0x3, %edi
jge 0x7177
movq 0x18(%rdx), %rdx
jmp 0x7197
movb $0x1, %al
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/importantSubtrees.c
// Function: graph2ComponentCleanup
void graph2ComponentCleanup(struct Graph* g, struct Graph* components, struct GraphPool* gp) {
	for (struct Graph* c=components; c!=NULL; c=c->next) {
		for (int v=0; v<c->n; ++v) {
			c->vertices[v] = NULL;
		}
		c->n = 0;
	}
	dumpGraphList(gp, components);
	for (int v=0; v<g->n; ++v) {
		g->vertices[v]->number = v;
	}
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
xorl %eax, %eax
movq %rsi, %rcx
testq %rcx, %rcx
je 0x73f9
movl (%rcx), %edi
testl %edi, %edi
cmovlel %eax, %edi
xorl %r8d, %r8d
cmpq %r8, %rdi
je 0x73f0
movq 0x10(%rcx), %r9
andq $0x0, (%r9,%r8,8)
incq %r8
jmp 0x73dd
andl $0x0, (%rcx)
movq 0x18(%rcx), %rcx
jmp 0x73ce
movq %rdx, %rdi
callq 0x116ef
movslq (%rbx), %rax
xorl %ecx, %ecx
cmpq %rax, %rcx
jge 0x741b
movq 0x10(%rbx), %rdx
movq (%rdx,%rcx,8), %rdx
movl %ecx, 0x18(%rdx)
incq %rcx
jmp 0x7406
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/importantSubtrees.c
// Function: importanceCount
int importanceCount(struct Graph* g, struct Graph* h, struct GraphPool* gp) {
	struct Graph* components = graph2Components(g, gp);
	int freq = 0;
	for (struct Graph* component=components; component!=NULL; component=component->next) {
		if (isSubtree(component, h, gp)) {
			++freq;
		}
	}
	graph2ComponentCleanup(g, components, gp);
	return freq;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, %r14
movq %rdx, %rsi
callq 0x7278
movq %rax, %r12
xorl %ebp, %ebp
movq %rax, %r13
testq %r13, %r13
je 0x745f
movq %r13, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x86b2
cmpb $0x1, %al
sbbl $-0x1, %ebp
movq 0x18(%r13), %r13
jmp 0x7441
movq %r14, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x73c5
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/importantSubtrees.c
// Function: importanceRelative
double importanceRelative(struct Graph* g, struct Graph* h, struct GraphPool* gp) {
	struct Graph* components = graph2Components(g, gp);
	int freq = 0;
	int count = 0;
	for (struct Graph* component=components; component!=NULL; component=component->next) {
		if (isSubtree(component, h, gp)) {
			++freq;
		}
		++count;
	}
	graph2ComponentCleanup(g, components, gp);
	return ((double)freq) / ((double)count);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r15
movq %rdi, (%rsp)
movq %rdx, %rsi
callq 0x7278
movq %rax, %r12
xorl %ebp, %ebp
xorl %r14d, %r14d
movq %rax, %r13
testq %r13, %r13
je 0x74c7
movq %r13, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x86b2
cmpb $0x1, %al
sbbl $-0x1, %ebp
incl %r14d
movq 0x18(%r13), %r13
jmp 0x74a6
movq (%rsp), %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0x73c5
cvtsi2sd %ebp, %xmm0
cvtsi2sd %r14d, %xmm1
divsd %xmm1, %xmm0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/intMath.c
// Function: ipow
int ipow(int b, int e){
    //negative sucks just treat it as zero.
    int r;
    if(e<=0) return 1;
    if(e%2==0){
        r=ipow(b,e/2);
        return r*r;
    }
    return b*ipow(b,e-1);
}

// Assembly:
pushq %rbx
pushq $0x1
popq %rbx
testl %esi, %esi
jle 0x755d
testb $0x1, %sil
je 0x7550
decl %esi
imull %edi, %ebx
jmp 0x753f
shrl %esi
callq 0x753b
imull %eax, %ebx
imull %eax, %ebx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/intSet.c
// Function: getIntElement
struct IntElement* getIntElement() {
	struct IntElement* e = malloc(sizeof(struct IntElement));
	e->value = 0;
	e->next = NULL;
	return e;
}

// Assembly:
pushq %rax
pushq $0x10
popq %rdi
callq 0x1180
andl $0x0, (%rax)
andq $0x0, 0x8(%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/intSet.c
// Function: getIntSet
struct IntSet* getIntSet() {
	struct IntSet* s = malloc(sizeof(struct IntSet));
	s->first = NULL;
	s->last = NULL;
	s->size = 0;
	return s;
}

// Assembly:
pushq %rax
pushq $0x20
popq %rdi
callq 0x1180
andq $0x0, 0x18(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/intSet.c
// Function: printIntSet
void printIntSet(struct IntSet* s, FILE*out) {
	fprintf(out, "%zu elements: [", s->size);
	for (struct IntElement* i=s->first; i!=NULL; i=i->next) {
		fprintf(out, "%i, ", i->value);
	}
	fprintf(out, "]\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movq 0x18(%rdi), %rdx
leaq 0x15db9(%rip), %rsi     # 0x1d3db
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1150
leaq 0x15db8(%rip), %r15     # 0x1d3eb
movq (%r14), %r14
testq %r14, %r14
je 0x7651
movl (%r14), %edx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x1150
addq $0x8, %r14
jmp 0x7633
leaq 0x15a18(%rip), %rdi     # 0x1d070
pushq $0x2
popq %rsi
pushq $0x1
popq %rdx
movq %rbx, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x1210
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/intSet.c
// Function: printIntSetAsLibSvm
void printIntSetAsLibSvm(struct IntSet* s, int label, FILE* out) {
	fprintf(out, "%i", label);
	for (struct IntElement* i=s->first; i!=NULL; i=i->next) {
		fprintf(out, " %i:1", i->value);
	}
	fprintf(out, "\n");
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rdx, %rbx
movl %esi, %edx
movq %rdi, %r14
leaq 0x16e8b(%rip), %rsi     # 0x1e54a
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1150
leaq 0x15d20(%rip), %r15     # 0x1d3f0
movq (%r14), %r14
testq %r14, %r14
je 0x76ee
movl (%r14), %edx
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x1150
addq $0x8, %r14
jmp 0x76d0
pushq $0xa
popq %rdi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x1100
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/intSet.c
// Function: appendInt
void appendInt(struct IntSet* s, int i) {
	struct IntElement* e = getIntElement();
	e->value = i;
	if (s->last != NULL) {
		s->last->next = e;
		s->last = e; 
	} else {
		s->first = s->last = e;
	}
	s->size += 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebx
movq %rdi, %r14
callq 0x75c8
movl %ebx, (%rax)
movq 0x8(%r14), %rcx
leaq 0x8(%rcx), %rdx
testq %rcx, %rcx
cmoveq %r14, %rdx
movq %rax, (%rdx)
movq %rax, 0x8(%r14)
incq 0x18(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/intSet.c
// Function: addIntSortedWithDuplicates
void addIntSortedWithDuplicates(struct IntSet* s, int i) {
	struct IntElement* newElement = getIntElement();
	newElement->value = i;
	if (s->last != NULL) {
		if (s->last->value <= i) {
			s->last->next = newElement;
			s->last = newElement;
		} else {
			if (s->first->value > i) {
				newElement->next = s->first;
				s->first = newElement;
			} else {
				for (struct IntElement* e=s->first; e!=NULL; e=e->next) {
					if (e->next->value > i) {
						newElement->next = e->next;
						e->next = newElement;
						break;
					}
				}
			}
		}
	} else {
		s->first = s->last = newElement;
	}
	s->size += 1;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
callq 0x75c8
movl %ebp, (%rax)
leaq 0x8(%rbx), %rcx
movq 0x8(%rbx), %rdx
testq %rdx, %rdx
je 0x77d4
cmpl %ebp, (%rdx)
jle 0x77dc
movq (%rbx), %rdx
cmpl %ebp, (%rdx)
jle 0x77bf
movq %rdx, 0x8(%rax)
jmp 0x77d7
movq %rdx, %rcx
movq 0x8(%rdx), %rdx
cmpl %ebp, (%rdx)
jle 0x77bf
addq $0x8, %rcx
movq %rdx, 0x8(%rax)
jmp 0x77e0
movq %rax, (%rcx)
movq %rbx, %rcx
jmp 0x77e0
movq %rax, 0x8(%rdx)
movq %rax, (%rcx)
incq 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/intSet.c
// Function: addIntSortedNoDuplicates
void addIntSortedNoDuplicates(struct IntSet* s, int i) {
	if (s->last != NULL) {
		if (s->last->value == i) {
			return;
		}
		if (s->last->value < i) {
			struct IntElement* newElement = getIntElement();
			newElement->value = i;
			s->last->next = newElement;
			s->last = newElement;
			s->size += 1;
			return;
		}
		if (s->last->value > i) {
			if (s->first->value == i) {
				return;
			}
			if (s->first->value > i) {
				struct IntElement* newElement = getIntElement();
				newElement->value = i;
				newElement->next = s->first;
				s->first = newElement;
				s->size += 1;
				return;
			}
			if (s->first->value < i) {
				for (struct IntElement* e=s->first; e!=NULL; e=e->next) {
					if (e->next->value == i) {
						return;
					}
					if (e->next->value > i) {
						struct IntElement* newElement = getIntElement();
						newElement->value = i;
						newElement->next = e->next;
						e->next = newElement;
						s->size += 1;
						return;
					}
				}
			}
		}
	} else {
		struct IntElement* newElement = getIntElement();
		newElement->value = i;
		s->first = s->last = newElement;
		s->size += 1;
		return;
	}
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movq 0x8(%rdi), %rax
testq %rax, %rax
je 0x781d
movl (%rax), %eax
cmpl %ebp, %eax
je 0x782f
jge 0x7834
callq 0x75c8
movl %ebp, (%rax)
movq 0x8(%rbx), %rcx
movq %rax, 0x8(%rcx)
movq %rax, 0x8(%rbx)
jmp 0x782b
callq 0x75c8
movl %ebp, (%rax)
movq %rax, 0x8(%rbx)
movq %rax, (%rbx)
incq 0x18(%rbx)
popq %rbx
popq %r14
popq %rbp
retq
jle 0x782f
movq (%rbx), %rax
movl (%rax), %ecx
cmpl %ebp, %ecx
je 0x782f
jle 0x7851
callq 0x75c8
movl %ebp, (%rax)
movq (%rbx), %rcx
movq %rcx, 0x8(%rax)
jmp 0x7828
jge 0x782f
movq %rax, %r14
movq 0x8(%rax), %rax
cmpl %ebp, (%rax)
je 0x782f
jle 0x7853
callq 0x75c8
movl %ebp, (%rax)
movq 0x8(%r14), %rcx
movq %rcx, 0x8(%rax)
movq %rax, 0x8(%r14)
jmp 0x782b
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/intSet.c
// Function: popIntElement
struct IntElement* popIntElement(struct IntSet* s) {
	struct IntElement* e = s->first;
	if (e != NULL) { 
		s->first = e->next;
		if (e->next == NULL) {
			s->last = NULL;
		}
		s->size -= 1;
		e->next = NULL;
	}
	return e;
}

// Assembly:
movq (%rdi), %rax
testq %rax, %rax
je 0x78b2
movq 0x8(%rax), %rcx
movq %rcx, (%rdi)
testq %rcx, %rcx
jne 0x78a9
andq $0x0, 0x8(%rdi)
decq 0x18(%rdi)
andq $0x0, 0x8(%rax)
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/intSet.c
// Function: intersectIntSet
struct IntSet* intersectIntSet(const struct IntSet* setA, const struct IntSet* setB) {
  struct IntSet* intersection = getIntSet();
  struct IntElement* a = setA->first;
  struct IntElement* b = setB->first;
 
  /* Once one or the other list runs out -- we're done */
  while (a != NULL && b != NULL)
  {
    if (a->value == b->value)
    {
       appendInt(intersection, a->value);
       a = a->next;
       b = b->next;
    }
    else if (a->value < b->value) /* advance the smaller list */      
       a = a->next;
    else
       b = b->next;
  }
  return intersection;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %r15
movq %rdi, %rbx
callq 0x75db
movq %rax, %r14
movq (%r15), %r15
movq (%rbx), %rbx
testq %rbx, %rbx
je 0x78f7
testq %r15, %r15
je 0x78f7
movl (%rbx), %esi
cmpl (%r15), %esi
je 0x78e5
jl 0x78f1
movq 0x8(%r15), %r15
jmp 0x78cc
movq %r14, %rdi
callq 0x7760
movq 0x8(%r15), %r15
addq $0x8, %rbx
jmp 0x78c9
movq %r14, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/intSet.c
// Function: isSortedIntSet
char isSortedIntSet(struct IntSet* s) {
	if (s->size < 2) {
		return 1;
	}
	for (struct IntElement* e=s->first; e->next!=NULL; e=e->next) {
		if (e->value > e->next->value) {
			return 0;
		}
	}
	return 1;
}

// Assembly:
movb $0x1, %al
cmpq $0x2, 0x18(%rdi)
jb 0x7924
movq (%rdi), %rax
movq 0x8(%rax), %rcx
testq %rcx, %rcx
je 0x791e
movl (%rax), %edx
movq %rcx, %rax
cmpl (%rcx), %edx
jle 0x790c
testq %rcx, %rcx
sete %al
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/intSet.c
// Function: isSortedUniqueIntSet
char isSortedUniqueIntSet(struct IntSet* s) {
	if (s->size < 2) {
		return 1;
	}
	for (struct IntElement* e=s->first; e->next!=NULL; e=e->next) {
		if (e->value >= e->next->value) {
			return 0;
		}
	}
	return 1;
}

// Assembly:
movb $0x1, %al
cmpq $0x2, 0x18(%rdi)
jb 0x7949
movq (%rdi), %rax
movq 0x8(%rax), %rcx
testq %rcx, %rcx
je 0x7943
movl (%rax), %edx
movq %rcx, %rax
cmpl (%rcx), %edx
jl 0x7931
testq %rcx, %rcx
sete %al
retq
nop
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/iterativeSubtreeIsomorphism.c
// Function: computeCharacteristicCached
int computeCharacteristicCached(struct SubtreeIsoDataStore data, struct CachedGraph* cachedB, struct Vertex* y, struct Vertex* u, struct Vertex* v, struct GraphPool* gp) {
	struct Graph* B = makeBipartiteInstanceFromVerticesCached(data, cachedB, y, u, v, gp);
	char hasMatchingCoveringAll = bipartiteMatchingTerminateEarly(B);
	returnCachedGraph(cachedB);
	return hasMatchingCoveringAll;
}

// Assembly:
pushq %rbp
pushq %rbx
subq $0x28, %rsp
movq %rdi, %rbx
movq 0x60(%rsp), %rax
movq %rax, 0x20(%rsp)
movaps 0x40(%rsp), %xmm0
movaps 0x50(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
callq 0x7bb7
movq %rax, %rdi
callq 0x1b19
movl %eax, %ebp
movq %rbx, %rdi
callq 0x1fd4
movsbl %bpl, %eax
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/iterativeSubtreeIsomorphism.c
// Function: getParentsFromPostorder
int* getParentsFromPostorder(struct Graph* g, int* postorder) {
	int* parents = malloc(g->n * sizeof(int));
	for (int i=0; i<g->n; ++i) {
		int v = postorder[i];
		parents[v] = g->vertices[v]->lowPoint;
	}
	return parents;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r14
movslq (%rdi), %r15
movq %r15, %rdi
shlq $0x2, %rdi
callq 0x1180
xorl %ecx, %ecx
testl %r15d, %r15d
movl $0x0, %edx
cmovgl %r15d, %edx
cmpq %rcx, %rdx
je 0x7de4
movslq (%rbx,%rcx,4), %rsi
movq 0x10(%r14), %rdi
movq (%rdi,%rsi,8), %rdi
movl 0x20(%rdi), %edi
movl %edi, (%rax,%rsi,4)
incq %rcx
jmp 0x7dc8
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/iterativeSubtreeIsomorphism.c
// Function: getParents
int* getParents(struct Graph* g, int root) {
	int* postorder = getPostorder(g, root);
	int* parents = getParentsFromPostorder(g, postorder);
	free(postorder);
	return parents;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
callq 0x1945b
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7da0
movq %rax, %rbx
movq %r14, %rdi
callq 0x1030
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/iterativeSubtreeIsomorphism.c
// Function: initG
struct SubtreeIsoDataStore initG(struct Graph* g) {
	struct SubtreeIsoDataStore info = {0};
	info.postorder = getPostorder(g, 0);
	info.g = g;
	return info;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
xorps %xmm0, %xmm0
movups %xmm0, 0x10(%rdi)
andq $0x0, 0x20(%rdi)
movq %rsi, %rdi
xorl %esi, %esi
callq 0x1945b
movq %rax, (%r14)
movq %rbx, 0x8(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/iterativeSubtreeIsomorphism.c
// Function: initIterativeSubtreeCheckForSingleton
struct SubtreeIsoDataStore initIterativeSubtreeCheckForSingleton(struct SubtreeIsoDataStore base, struct Graph* h) {
	struct SubtreeIsoDataStore info = {0};
	// copy stuff from below
	info.g = base.g;
	info.postorder = base.postorder;
	info.h = h;

	struct Vertex* u = h->vertices[0];
	char* uLabel = u->label;

	// create cube
	createNewCubeForSingletonPattern(&info);

	for (int vi=0; vi<(info.g)->n; ++vi) {
		struct Vertex* v = (info.g)->vertices[info.postorder[vi]];

		if (labelCmp(v->label, uLabel) == 0) {
			// if vertex labels match, there is a characteristic (H^y_u, v)
			addCharacteristic(&info, u, u, v);
			info.foundIso = 1;
		}
	}

	return info;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
movaps 0x30(%rsp), %xmm0
movups %xmm0, (%rdi)
movq %rsi, 0x10(%rdi)
movq 0x10(%rsi), %rax
movq (%rax), %r14
movq (%r14), %r15
callq 0x13379
xorl %r13d, %r13d
movq 0x8(%rbx), %rax
movslq (%rax), %rcx
cmpq %rcx, %r13
jge 0x83c8
movq 0x10(%rax), %rax
movq (%rbx), %rcx
movslq (%rcx,%r13,4), %rcx
movq (%rax,%rcx,8), %r12
movq (%r12), %rdi
movq %r15, %rsi
callq 0x19340
testl %eax, %eax
jne 0x83c3
movq %rbx, %rdi
movq %r14, %rsi
movq %r14, %rdx
movq %r12, %rcx
callq 0x13402
movl $0x1, 0x20(%rbx)
incq %r13
jmp 0x8380
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/iterativeSubtreeIsomorphism.c
// Function: initIterativeSubtreeCheck
struct SubtreeIsoDataStore initIterativeSubtreeCheck(struct SubtreeIsoDataStore base, struct VertexList* patternEdge, struct GraphPool* gp) {
	// create graph from edge
	struct Graph* h = createGraph(2, gp);
	(h)->vertices[0]->label = patternEdge->startPoint->label;
	(h)->vertices[1]->label = patternEdge->endPoint->label;
	addEdgeBetweenVertices(0, 1, patternEdge->label, h, gp);

	return initIterativeSubtreeCheckForEdge(base, h);

}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbx
pushq $0x2
popq %rdi
movq %rdx, %rsi
callq 0x630e
movq %rax, %r12
movq 0x10(%r15), %rax
movq (%rax), %rax
movq 0x10(%r12), %rcx
movq (%rcx), %rdx
movq %rax, (%rdx)
movq 0x18(%r15), %rax
movq (%rax), %rax
movq 0x8(%rcx), %rcx
movq %rax, (%rcx)
movq (%r15), %rdx
pushq $0x1
popq %rsi
xorl %edi, %edi
movq %r12, %rcx
movq %r14, %r8
callq 0x6200
movq 0x70(%rsp), %rax
movq %rax, 0x20(%rsp)
movaps 0x50(%rsp), %xmm0
movaps 0x60(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rbx, %rdi
movq %r12, %rsi
callq 0x81d1
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/iterativeSubtreeIsomorphism.c
// Function: addNoncriticalVertexCharacteristics
void addNoncriticalVertexCharacteristics(struct SubtreeIsoDataStore* data, struct Graph* B, struct Vertex* u, struct Vertex* v) {
	/* the maximum matching computed above covers all but one neighbor of u
	we need to identify those covered neighbors that can be swapped with
	that uncovered neighbor without decreasing the cardinality of the matching
	these are exactly the non-critical vertices.

	a vertex is critical <=> 1.) AND NOT 2.)
	hence
	a vertex is non-critical <=> NOT 1.) OR 2.)
	where
	1.) matched in the matching above
	2.) reachable by augmenting path from the single unmatched vertex.
	This means, all vertices reachable from the single uncovered neighbor of u (including that neighbor are non-critical.
	*/
	struct Vertex* uncoveredNeighbor = NULL;

	// find the single uncovered neighbor of u
	for (int i=0; i<B->number; ++i) {
		if (!isMatched(B->vertices[i])) {
			uncoveredNeighbor = B->vertices[i];
			break;
		}
	}

	// mark all vertices reachable from uncoveredNeighbor by an augmenting path
	markReachable(uncoveredNeighbor, B->number);

	// add non-critical vertices to output
	for (int i=0; i<B->number; ++i) {
		if (B->vertices[i]->visited == 1) {
			// vertex is not critical, add characteristic
			addCharacteristicRaw(data, B->vertices[i]->lowPoint, u->number, v->number);
		}
	}
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %r12
xorl %r13d, %r13d
xorl %ebp, %ebp
movslq 0x8(%r15), %rsi
cmpq %rsi, %rbp
jge 0x84a7
movq 0x10(%r15), %rax
movq (%rax,%rbp,8), %rdi
callq 0x17d6
incq %rbp
testb %al, %al
jne 0x847d
movq 0x10(%r15), %rax
movq -0x8(%rax,%rbp,8), %r13
movl 0x8(%r15), %esi
movq %r13, %rdi
callq 0x19509
xorl %r13d, %r13d
movslq 0x8(%r15), %rax
cmpq %rax, %r13
jge 0x84e0
movq 0x10(%r15), %rax
movq (%rax,%r13,8), %rax
cmpl $0x1, 0x1c(%rax)
jne 0x84db
movl 0x20(%rax), %esi
movl 0x18(%r14), %edx
movl 0x18(%rbx), %ecx
movq %r12, %rdi
callq 0x1342c
incq %r13
jmp 0x84b2
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/iterativeSubtreeIsomorphism.c
// Function: noniterativeSubtreeCheck
struct SubtreeIsoDataStore noniterativeSubtreeCheck(struct SubtreeIsoDataStore base, struct Graph* h, struct GraphPool* gp) {
	struct SubtreeIsoDataStore info = {0};
	info.g = base.g;
	info.h = h;
	info.postorder = base.postorder;

	if (info.g->n > 0) {
		info.S = createNewCube(info.g->n, info.h->n);
		noniterativeSubtreeCheck_intern(&info, gp);
		dumpNewCube(info.S, info.g->n);
	} else {
		// if g is empty, then h only matches if it is empty as well.
		// g->n == 0 is a special case that is not handled well by the subtree iso algorithm
		info.foundIso = h->n == 0 ? 1 : 0;
	}

	info.S = NULL;
	return info;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rdi)
movq %rsi, 0x10(%rdi)
movq 0x20(%rsp), %rcx
movq %rcx, (%rdi)
movslq (%rax), %rdi
testq %rdi, %rdi
jle 0x8545
movq %rdx, %r14
movslq (%rsi), %rsi
callq 0x1336c
movq %rax, 0x18(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0x8560
movq 0x8(%rbx), %rax
movq 0x18(%rbx), %rdi
movl (%rax), %esi
callq 0x133ca
jmp 0x8550
xorl %eax, %eax
cmpl $0x0, (%rsi)
sete %al
movl %eax, 0x20(%rbx)
andq $0x0, 0x18(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/iterativeSubtreeIsomorphism.c
// Function: noniterativeSubtreeCheck_intern
static void noniterativeSubtreeCheck_intern(struct SubtreeIsoDataStore* current, struct GraphPool* gp) {

	struct Graph* g = current->g;
	struct Graph* h = current->h;

	struct CachedGraph* cachedB = initCachedGraph(gp, h->n);

	current->foundIso = 0;
	for (int vi=0; vi<g->n; ++vi) {
		struct Vertex* v = g->vertices[current->postorder[vi]];

		for (int ui=0; ui<h->n; ++ui) {
			struct Vertex* u = h->vertices[ui];

			// check if vertex labels match
			if (labelCmp(u->label, v->label) != 0) { continue; }

			// compute maximum matching
			struct Graph* B = makeBipartiteInstanceFromVerticesCached(*current, cachedB, u, u, v, gp);
			int sizeofMatching = bipartiteMatchingEvenMoreDirty(B);
			int nNeighbors = B->number;

			// is there a subgraph iso here?
			if (sizeofMatching == nNeighbors) {
				addCharacteristic(current, u, u, v);
				current->foundIso = 1;

				returnCachedGraph(cachedB);
				dumpCachedGraph(cachedB);
				return; // early termination when subtree iso is found
			}

			// compute partial subgraph isomorphisms
			if (sizeofMatching == nNeighbors - 1) {
				addNoncriticalVertexCharacteristics(current, B, u, v);
			}

			returnCachedGraph(cachedB);
		}
	}

	dumpCachedGraph(cachedB);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rax
movq %rdi, %rbx
movq 0x8(%rdi), %r14
movq 0x10(%rdi), %r15
movl (%r15), %esi
movq %rax, 0x40(%rsp)
movq %rax, %rdi
callq 0x1f1c
movq %rax, %rbp
movq %rbx, 0x28(%rsp)
andl $0x0, 0x20(%rbx)
xorl %edx, %edx
movq %r14, 0x30(%rsp)
movslq (%r14), %rax
cmpq %rax, %rdx
jge 0x869c
movq 0x10(%r14), %rax
movq 0x28(%rsp), %rcx
movq (%rcx), %rcx
movq %rdx, 0x38(%rsp)
movslq (%rcx,%rdx,4), %rcx
movq (%rax,%rcx,8), %r12
xorl %r14d, %r14d
movslq (%r15), %rax
cmpq %rax, %r14
jge 0x8661
movq 0x10(%r15), %rax
movq (%rax,%r14,8), %r13
movq (%r13), %rdi
movq (%r12), %rsi
callq 0x19340
testl %eax, %eax
jne 0x8659
movq 0x28(%rsp), %rcx
movq 0x20(%rcx), %rax
movq %rax, 0x20(%rsp)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq %rbp, %rbx
movq %rbp, %rdi
movq %r13, %rsi
movq %r13, %rdx
movq %r12, %rcx
movq 0x40(%rsp), %r8
callq 0x7bb7
movq %rax, %rbp
movq %rax, %rdi
callq 0x1aac
movl 0x8(%rbp), %ecx
cmpl %ecx, %eax
je 0x8673
decl %ecx
cmpl %ecx, %eax
jne 0x864e
movq 0x28(%rsp), %rdi
movq %rbp, %rsi
movq %r13, %rdx
movq %r12, %rcx
callq 0x8461
movq %rbx, %rbp
movq %rbx, %rdi
callq 0x1fd4
incq %r14
jmp 0x85c7
movq 0x38(%rsp), %rdx
incq %rdx
movq 0x30(%rsp), %r14
jmp 0x859f
movq 0x28(%rsp), %r14
movq %r14, %rdi
movq %r13, %rsi
movq %r13, %rdx
movq %r12, %rcx
callq 0x13402
movl $0x1, 0x20(%r14)
movq %rbx, %rbp
movq %rbx, %rdi
callq 0x1fd4
movq %rbp, %rdi
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x2032
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/iterativeSubtreeIsomorphism.c
// Function: isSubtree
char isSubtree(struct Graph* g, struct Graph* h, struct GraphPool* gp) {
	struct SubtreeIsoDataStore info = {0};
	info.g = g;
	info.h = h;

	if (info.g->n > 0) {
		info.postorder = getPostorder(g, 0);
		info.S = createNewCube(info.g->n, info.h->n);
		noniterativeSubtreeCheck_intern(&info, gp);
		dumpNewCube(info.S, info.g->n);
		free(info.postorder);
	} else {
		// if g is empty, then h only matches if it is empty as well.
		// g->n == 0 is a special case that is not handled well by the subtree iso algorithm
		info.foundIso = h->n == 0 ? 1 : 0;
	}

	return info.foundIso;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
subq $0x28, %rsp
movq %rsi, %r14
andq $0x0, 0x20(%rsp)
movq %rdi, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
cmpl $0x0, (%rdi)
jle 0x8725
movq %rdx, %rbx
movq %rdi, %r15
xorl %esi, %esi
callq 0x1945b
movq %rsp, %r12
movq %rax, (%r12)
movslq (%r15), %rdi
movslq (%r14), %rsi
callq 0x1336c
movq %rax, 0x18(%r12)
movq %r12, %rdi
movq %rbx, %rsi
callq 0x8560
movq 0x8(%r12), %rax
movq 0x18(%r12), %rdi
movl (%rax), %esi
callq 0x133ca
movq (%r12), %rdi
callq 0x1030
movl 0x20(%r12), %eax
jmp 0x872e
xorl %eax, %eax
cmpl $0x0, (%r14)
sete %al
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/iterativeSubtreeIsomorphism.c
// Function: computeRootedSubtreeEmbedding
struct Vertex* computeRootedSubtreeEmbedding(struct Graph* g, struct Vertex* gRoot, struct Graph* h, struct Vertex* hRoot, struct GraphPool* gp) {
	struct SubtreeIsoDataStore info = {0};
	info.g = g;
	info.h = h;
	struct Vertex* rootMapping = NULL;


	if (info.g->n > 0) {
		info.postorder = getPostorder(g, gRoot->number);
		info.S = createNewCube(info.g->n, info.h->n);
		rootMapping = noniterativeRootedSubtreeCheck_intern(&info, hRoot, gp);
		dumpNewCube(info.S, info.g->n);
		free(info.postorder);
	} else {
		// if g is empty, then h only matches if it is empty as well.
		// g->n == 0 is a special case that is not handled well by the subtree iso algorithm
		info.foundIso = h->n == 0 ? 1 : 0;
	}

	return rootMapping;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x30, %rsp
andq $0x0, 0x28(%rsp)
movq %rdi, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
cmpl $0x0, (%rdi)
jle 0x87b4
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %r12
movl 0x18(%rsi), %esi
callq 0x1945b
leaq 0x8(%rsp), %r13
movq %rax, (%r13)
movslq (%r12), %rdi
movslq (%r15), %rsi
callq 0x1336c
movq %rax, 0x18(%r13)
movq %r13, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0x87c7
movq %rax, %rbx
movq 0x8(%r13), %rax
movq 0x18(%r13), %rdi
movl (%rax), %esi
callq 0x133ca
movq (%r13), %rdi
callq 0x1030
jmp 0x87b6
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/iterativeSubtreeIsomorphism.c
// Function: noniterativeRootedSubtreeCheck
struct SubtreeIsoDataStore noniterativeRootedSubtreeCheck(struct SubtreeIsoDataStore base, struct Graph* h, struct Vertex** rootEmbedding, struct GraphPool* gp) {
	struct SubtreeIsoDataStore info = {0};
	info.g = base.g;
	info.h = h;
	info.postorder = base.postorder;

	if (info.g->n > 0) {
		info.S = createNewCube(info.g->n, info.h->n);
		*rootEmbedding = noniterativeRootedSubtreeCheck_intern(&info, h->vertices[0], gp);
		dumpNewCube(info.S, info.g->n);
	} else {
		// if g is empty, then h only matches if it is empty as well.
		// g->n == 0 is a special case that is not handled well by the subtree iso algorithm
		info.foundIso = h->n == 0 ? 1 : 0;
	}

	info.S = NULL;
	return info;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rcx, %r15
movq %rsi, %r12
movq %rdi, %rbx
xorps %xmm0, %xmm0
movups %xmm0, 0x18(%rdi)
movq 0x38(%rsp), %rax
movq %rax, 0x8(%rdi)
movq %rsi, 0x10(%rdi)
movq 0x30(%rsp), %rcx
movq %rcx, (%rdi)
movslq (%rax), %rdi
testq %rdi, %rdi
jle 0x89b9
movq %rdx, %r14
movslq (%r12), %rsi
callq 0x1336c
movq %rax, 0x18(%rbx)
movq 0x10(%r12), %rax
movq (%rax), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0x87c7
movq %rax, (%r14)
movq 0x8(%rbx), %rax
movq 0x18(%rbx), %rdi
movl (%rax), %esi
callq 0x133ca
jmp 0x89c6
xorl %eax, %eax
cmpl $0x0, (%r12)
sete %al
movl %eax, 0x20(%rbx)
andq $0x0, 0x18(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
nop
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/kruskalsAlgorithm.c
// Function: kruskalMST
struct ShallowGraph* kruskalMST(struct Graph* g, struct VertexList** sortedEdges, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	struct Graph* branching = createGraph(g->n, gp);
	struct ShallowGraph* spanningTree = getShallowGraph(sgp);
	int i;

	for (i=0; i<g->m; ++i) {
		if (isCycleFree(branching, sortedEdges[i], sgp->listPool)) {
			appendEdge(spanningTree, shallowCopyEdge(sortedEdges[i], sgp->listPool));
		}
	}

	dumpGraph(gp, branching);
	return spanningTree;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x18, %rsp
movq %rcx, %r14
movq %rsi, %r15
movq %rdi, %r12
movl (%rdi), %edi
movq %rdx, 0x10(%rsp)
movq %rdx, %rsi
callq 0x630e
movq %rax, 0x8(%rsp)
movq %r14, %rdi
callq 0x117e9
movq %rax, (%rsp)
xorl %r13d, %r13d
movslq 0x4(%r12), %rax
cmpq %rax, %r13
jge 0x8ada
movq (%r15,%r13,8), %rax
movq 0x8(%rsp), %rcx
movq 0x10(%rcx), %rcx
movq 0x10(%rax), %rdx
movq 0x18(%rax), %rax
movslq 0x18(%rdx), %rdx
movq (%rcx,%rdx,8), %rdi
movslq 0x18(%rax), %rax
movq (%rcx,%rax,8), %rbx
callq 0x8afc
movq %rax, %rbp
movq %rbx, %rdi
callq 0x8afc
cmpq %rax, %rbp
je 0x8ad2
movq %rax, %rbx
movq 0x10(%r14), %rdi
callq 0x11307
movl 0x28(%rbp), %ecx
cmpl 0x28(%rbx), %ecx
jge 0x8a93
movq %rbp, 0x10(%rax)
movq %rbx, 0x18(%rax)
movq %rbp, %rdi
movq %rax, %rsi
callq 0x5b2c
movl 0x28(%rbp), %eax
cmpl 0x28(%rbx), %eax
jne 0x8ab9
addq $0x28, %rbx
jmp 0x8ab5
movq %rbx, 0x10(%rax)
movq %rbp, 0x18(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x5b2c
movl 0x28(%rbp), %eax
cmpl 0x28(%rbx), %eax
jne 0x8ab9
addq $0x28, %rbp
movq %rbp, %rbx
incl %eax
movl %eax, (%rbx)
movq (%r15,%r13,8), %rdi
movq 0x10(%r14), %rsi
callq 0x5a28
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x6620
incq %r13
jmp 0x8a16
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x1166e
movq (%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/kruskalsAlgorithm.c
// Function: getRoot
static struct Vertex* getRoot(struct Vertex* v) {
	struct Vertex* r = v;
	while (r->neighborhood != NULL) {
		r = r->neighborhood->endPoint; 
	}
	return r;
}

// Assembly:
movq %rdi, %rax
movq 0x8(%rax), %rcx
testq %rcx, %rcx
je 0x8b0e
movq 0x18(%rcx), %rax
jmp 0x8aff
retq
nop
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/listComponents.c
// Function: computeCriticality
int* computeCriticality(struct ShallowGraph* biconnectedComponents, int n) {

	/* store for each vertex if the current bic.comp was already counted */
	int* occurrences = malloc(n * sizeof(int));
	/* store the cycle degrees of each vertex in g */
	int* cycleDegrees = malloc(n * sizeof(int));

	int v;
	struct ShallowGraph* comp;
	int compNumber = 0;

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


	for (comp = biconnectedComponents; comp!=NULL; comp=comp->next) {
		struct VertexList* e;
		for (e=comp->edges; e!=NULL; e=e->next) {
			if (occurrences[e->startPoint->number] < compNumber) {
				occurrences[e->startPoint->number] = compNumber;
				++cycleDegrees[e->startPoint->number];
			}
			if (occurrences[e->endPoint->number] < compNumber) {
				occurrences[e->endPoint->number] = compNumber;
				++cycleDegrees[e->endPoint->number];
			}
		}
		++compNumber;				
	}
	free(occurrences);
	return cycleDegrees;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %rbx
movslq %esi, %r12
leaq (,%r12,4), %r15
movq %r15, %rdi
callq 0x1180
movq %rax, %r14
movq %r15, %rdi
callq 0x1180
movq %rax, %r15
xorl %eax, %eax
testl %r12d, %r12d
cmovlel %eax, %r12d
cmpq %rax, %r12
je 0x8b59
orl $-0x1, (%r14,%rax,4)
andl $0x0, (%r15,%rax,4)
incq %rax
jmp 0x8b45
xorl %eax, %eax
testq %rbx, %rbx
je 0x8ba5
movq %rbx, %rcx
movq (%rcx), %rcx
testq %rcx, %rcx
je 0x8b9d
movq 0x10(%rcx), %rdx
movslq 0x18(%rdx), %rdx
cmpl %eax, (%r14,%rdx,4)
jge 0x8b81
movl %eax, (%r14,%rdx,4)
incl (%r15,%rdx,4)
movq 0x18(%rcx), %rdx
movslq 0x18(%rdx), %rdx
cmpl %eax, (%r14,%rdx,4)
jge 0x8b97
movl %eax, (%r14,%rdx,4)
incl (%r15,%rdx,4)
addq $0x8, %rcx
jmp 0x8b63
incl %eax
movq 0x18(%rbx), %rbx
jmp 0x8b5b
movq %r14, %rdi
callq 0x1030
movq %r15, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/listComponents.c
// Function: getMaxBlockDegree
int getMaxBlockDegree(struct Graph* g, struct ShallowGraphPool* sgp) {
	int maxDegree = -1;
	struct ShallowGraph* biconnectedComponents = listBiconnectedComponents(g, sgp);
	int* cycleDegrees = computeBlockDegrees(biconnectedComponents, g->n);

	int v;
	for (v=0; v<g->n; ++v) {
		if (maxDegree < cycleDegrees[v]) {
			maxDegree = cycleDegrees[v];
		}
	}

	free(cycleDegrees);
	dumpShallowGraphCycle(sgp, biconnectedComponents);
	return maxDegree;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
callq 0x8ccd
movq %rax, %r14
movl (%r15), %esi
movq %rax, %rdi
callq 0x8bbc
movl (%r15), %ecx
xorl %edx, %edx
testl %ecx, %ecx
cmovlel %edx, %ecx
pushq $-0x1
popq %rbp
cmpq %rdx, %rcx
je 0x8cad
movl (%rax,%rdx,4), %esi
cmpl %esi, %ebp
cmovlel %esi, %ebp
incq %rdx
jmp 0x8c9b
movq %rax, %rdi
callq 0x1030
movq %rbx, %rdi
movq %r14, %rsi
callq 0x11888
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/listComponents.c
// Function: listBiconnectedComponents
struct ShallowGraph* listBiconnectedComponents(struct Graph* g, struct ShallowGraphPool *gp) {
	int i;

	/* __tarjanFBC needs a static (artificial) head of stack */
	struct VertexList *headOfStack = getVertexList(gp->listPool);

	/* this is where the magic happens. For all vertices: if the vertex is not visited yet,
	 * start find biconnected components for its connected component. This yields a list of
	 * all biconnected components in the graph. */
	struct ShallowGraph *allComponents = NULL;

	/* init ->visited to zero */
	for (i=0; i<g->n; ++i) {
		g->vertices[i]->visited = 0;
	}

	for (i=0; i<g->n; ++i) {
		if (g->vertices[i]->visited == 0) {
			struct ShallowGraph* currentComponents = __tarjanFBC(g->vertices[i], g->vertices[i], 0, headOfStack, gp->listPool, gp);
			allComponents = addComponent(allComponents, currentComponents);
		}
	}


	/* __tarjanFBC returns a cycle of ShallowGraphs. Convert it to a list */
	if (allComponents) {
		allComponents->prev->next = NULL;
		allComponents->prev = NULL;
	} else {
		/* this case should not occur */
		fprintf(stderr, "Error: No cycle of shallow graphs after __tarjanFBC\n");
	}

	/* garbage collection */
	dumpVertexList(gp->listPool, headOfStack);

	/*return results */
	return allComponents;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rsi, %rbx
movq %rdi, %r15
movq 0x10(%rsi), %rdi
callq 0x11307
movq %rax, %r14
movl (%r15), %eax
xorl %ecx, %ecx
testl %eax, %eax
movl $0x0, %edx
cmovgl %eax, %edx
cmpq %rcx, %rdx
je 0x8d0d
movq 0x10(%r15), %rsi
movq (%rsi,%rcx,8), %rsi
andl $0x0, 0x1c(%rsi)
incq %rcx
jmp 0x8cf7
xorl %r13d, %r13d
xorl %r12d, %r12d
movslq %eax, %rcx
cmpq %rcx, %r13
jge 0x8d53
movq 0x10(%r15), %rcx
movq (%rcx,%r13,8), %rdi
cmpl $0x0, 0x1c(%rdi)
jne 0x8d4e
movq 0x10(%rbx), %r8
movq %rdi, %rsi
xorl %edx, %edx
movq %r14, %rcx
movq %rbx, %r9
callq 0x9336
movq %r12, %rdi
movq %rax, %rsi
callq 0x656a
movq %rax, %r12
movl (%r15), %eax
incq %r13
jmp 0x8d13
testq %r12, %r12
je 0x8d81
movq 0x20(%r12), %rax
andq $0x0, 0x18(%rax)
andq $0x0, 0x20(%r12)
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x11364
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
movq 0x21270(%rip), %rax     # 0x29ff8
movq (%rax), %rcx
leaq 0x14668(%rip), %rdi     # 0x1d3fa
pushq $0x34
popq %rsi
pushq $0x1
popq %rdx
callq 0x1210
jmp 0x8d68
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/listComponents.c
// Function: getMinBlockDegree
int getMinBlockDegree(struct Graph* g, struct ShallowGraphPool* sgp) {
	int minDegree = INT_MAX;
	struct ShallowGraph* biconnectedComponents = listBiconnectedComponents(g, sgp);
	int* cycleDegrees = computeBlockDegrees(biconnectedComponents, g->n);

	int v;
	for (v=0; v<g->n; ++v) {
		if (minDegree > cycleDegrees[v]) {
			minDegree = cycleDegrees[v];
		}
	}

	free(cycleDegrees);
	dumpShallowGraphCycle(sgp, biconnectedComponents);
	return minDegree;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r15
callq 0x8ccd
movq %rax, %r14
movl (%r15), %esi
movq %rax, %rdi
callq 0x8bbc
movl (%r15), %ecx
xorl %edx, %edx
testl %ecx, %ecx
cmovlel %edx, %ecx
movl $0x7fffffff, %ebp       # imm = 0x7FFFFFFF
cmpq %rdx, %rcx
je 0x8de0
movl (%rax,%rdx,4), %esi
cmpl %esi, %ebp
cmovgel %esi, %ebp
incq %rdx
jmp 0x8dce
movq %rax, %rdi
callq 0x1030
movq %rbx, %rdi
movq %r14, %rsi
callq 0x11888
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/listComponents.c
// Function: getNumberOfBiconnectedComponents
int getNumberOfBiconnectedComponents(struct Graph* g, struct ShallowGraphPool* sgp) {
	struct ShallowGraph* biconnectedComponents = listBiconnectedComponents(g, sgp);
	int compNumber = 0;
	for (struct ShallowGraph* comp = biconnectedComponents; comp!=NULL; comp=comp->next) {
			++compNumber;
	}
	/* cleanup */
	dumpShallowGraphCycle(sgp, biconnectedComponents);
	return compNumber;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
callq 0x8ccd
xorl %ebp, %ebp
movq %rax, %rcx
testq %rcx, %rcx
je 0x8e1d
incl %ebp
movq 0x18(%rcx), %rcx
jmp 0x8e10
movq %rbx, %rdi
movq %rax, %rsi
callq 0x11888
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/listComponents.c
// Function: getNumberOfBlocks
int getNumberOfBlocks(struct Graph* g, struct ShallowGraphPool* sgp) {
	if (g->m == 0) {
		return 0;
	}
	struct ShallowGraph* biconnectedComponents = listBiconnectedComponents(g, sgp);
	struct ShallowGraph* comp;
	int compNumber = 0;
	for (comp = biconnectedComponents; comp!=NULL; comp=comp->next) {
		if (comp->m > 1) {
			++compNumber;
		}			
	}
	/* cleanup */
	dumpShallowGraphCycle(sgp, biconnectedComponents);
	return compNumber;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
cmpl $0x0, 0x4(%rdi)
je 0x8e6a
movq %rsi, %rbx
callq 0x8ccd
xorl %ebp, %ebp
movq %rax, %rcx
testq %rcx, %rcx
je 0x8e5d
xorl %edx, %edx
cmpl $0x2, 0x10(%rcx)
setge %dl
addl %edx, %ebp
movq 0x18(%rcx), %rcx
jmp 0x8e47
movq %rbx, %rdi
movq %rax, %rsi
callq 0x11888
jmp 0x8e6c
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/listComponents.c
// Function: getMaxNumberOfBlocksPerComponent
int getMaxNumberOfBlocksPerComponent(struct Graph* g, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	struct Graph* components = listConnectedComponents(g, gp);
	int maxNumberOfBlocks = 0;
	for (struct Graph* comp=components; comp!=NULL; comp=comp->next) {
		int numberOfBlocks = getNumberOfBlocks(comp, sgp);
		maxNumberOfBlocks = numberOfBlocks > maxNumberOfBlocks ? numberOfBlocks : maxNumberOfBlocks;
	}
	return maxNumberOfBlocks;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdx, %rbx
callq 0x8ea8
movq %rax, %r14
xorl %ebp, %ebp
testq %r14, %r14
je 0x8ea1
movq %r14, %rdi
movq %rbx, %rsi
callq 0x8e31
cmpl %ebp, %eax
cmovgl %eax, %ebp
movq 0x18(%r14), %r14
jmp 0x8e86
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq