LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0x1711d(%rip), %rsi     # 0x203a0
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1160
cmpl $0x0, (%r14)
jle 0x9327
leaq 0x1712d(%rip), %r15     # 0x203cb
xorl %r12d, %r12d
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 0x1160
incq %r12
movslq (%r14), %rax
cmpq %rax, %r12
jl 0x92a1
testl %eax, %eax
jle 0x9327
leaq 0x170f3(%rip), %r15     # 0x203c5
xorl %r12d, %r12d
movq 0x10(%r14), %rcx
movq (%rcx,%r12,8), %rcx
movq 0x8(%rcx), %r13
testq %r13, %r13
je 0x931c
movq 0x10(%r13), %rax
movq 0x18(%r13), %rcx
movl 0x18(%rax), %edx
movl 0x18(%rcx), %ecx
cmpl %ecx, %edx
jge 0x9310
movq 0x10(%r14), %rax
movq (%rax,%r12,8), %rax
movq (%rax), %r8
movq %rbx, %rdi
movq %r15, %rsi
xorl %eax, %eax
callq 0x1160
movq 0x8(%r13), %r13
testq %r13, %r13
jne 0x92e6
movl (%r14), %eax
incq %r12
movslq %eax, %rcx
cmpq %rcx, %r12
jl 0x92d5
leaq 0x17094(%rip), %rdi     # 0x203c2
movl $0x2, %esi
movl $0x1, %edx
movq %rbx, %rcx
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
jmp 0x1220
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O3/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 0xb23b
movq %rax, %r14
movl (%r15), %esi
movq %rax, %rdi
callq 0xb068
movslq (%r15), %rcx
testq %rcx, %rcx
jle 0x950d
xorl %edx, %edx
cmpl $0x3, (%rax,%rdx,4)
jge 0x95c9
incq %rdx
cmpq %rdx, %rcx
jne 0x94fb
movb $0x1, %cl
testq %r14, %r14
je 0x95de
xorl %edx, %edx
movq %r14, %rsi
cmpl $0x1, 0x10(%rsi)
je 0x95ba
movq (%rsi), %rdi
movq %rdi, %r8
testq %rdi, %rdi
je 0x95ba
movq 0x10(%r8), %r9
movl %edx, 0x1c(%r9)
movq 0x18(%r8), %r9
movl %edx, 0x1c(%r9)
movq 0x8(%r8), %r8
testq %r8, %r8
jne 0x9536
testq %rdi, %rdi
je 0x95ba
xorl %r8d, %r8d
movq 0x10(%rdi), %r9
cmpl $0x0, 0x1c(%r9)
jne 0x957b
movl $0x1, 0x1c(%r9)
movslq 0x18(%r9), %r10
movl $0x1, %r9d
cmpl $0x1, (%rax,%r10,4)
jg 0x957e
xorl %r9d, %r9d
movq 0x18(%rdi), %r10
cmpl $0x0, 0x1c(%r10)
jne 0x95a2
movl $0x1, 0x1c(%r10)
movslq 0x18(%r10), %r11
movl $0x1, %r10d
cmpl $0x1, (%rax,%r11,4)
jg 0x95a5
xorl %r10d, %r10d
addl %r9d, %r8d
addl %r10d, %r8d
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
jne 0x9557
cmpl $0x3, %r8d
jge 0x95c9
movq 0x18(%rsi), %rsi
testq %rsi, %rsi
jne 0x951d
jmp 0x95de
movq %rax, %rdi
callq 0x1030
movq %rbx, %rdi
movq %r14, %rsi
callq 0x14a56
xorl %ecx, %ecx
movl %ecx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
testq %rsi, %rsi
je 0x97aa
movq %rsi, %rax
movslq (%rax), %rcx
testq %rcx, %rcx
jle 0x979b
xorl %edi, %edi
movq 0x10(%rax), %r8
movq $0x0, (%r8,%rdi,8)
incq %rdi
cmpq %rdi, %rcx
jne 0x9787
movl $0x0, (%rax)
movq 0x18(%rax), %rax
testq %rax, %rax
jne 0x977d
movq %rdx, %rdi
callq 0x147c9
movslq (%rbx), %rax
testq %rax, %rax
jle 0x97cf
movq 0x10(%rbx), %rcx
xorl %edx, %edx
movq (%rcx,%rdx,8), %rsi
movl %edx, 0x18(%rsi)
incq %rdx
cmpq %rdx, %rax
jne 0x97c0
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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, %r12
movq %rdi, %r14
movq %rdx, %rsi
callq 0x9618
movq %rax, %r15
xorl %ebp, %ebp
testq %rax, %rax
je 0x9816
movq %r15, %r13
movq %r13, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0xabef
cmpb $0x1, %al
sbbl $-0x1, %ebp
movq 0x18(%r13), %r13
testq %r13, %r13
jne 0x97fa
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x9771
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_O3/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, %r12
movq %rdi, %r14
movq %rdx, %rsi
callq 0x9618
movq %rax, %r15
testq %rax, %rax
je 0x9893
movq %r14, (%rsp)
xorl %ebp, %ebp
movq %r15, %r13
xorl %r14d, %r14d
movq %r13, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0xabef
cmpb $0x1, %al
sbbl $-0x1, %r14d
incl %ebp
movq 0x18(%r13), %r13
testq %r13, %r13
jne 0x9865
cvtsi2sd %r14d, %xmm1
cvtsi2sd %ebp, %xmm0
movq (%rsp), %r14
jmp 0x989b
xorpd %xmm1, %xmm1
xorpd %xmm0, %xmm0
divsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x9771
movsd (%rsp), %xmm0
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x1, %ebx
testl %esi, %esi
jle 0x993b
testb $0x1, %sil
je 0x992e
leal -0x1(%rsi), %eax
imull %edi, %ebx
cmpl $0x2, %esi
movl %eax, %esi
jge 0x9919
jmp 0x993b
shrl %esi
callq 0x990f
imull %eax, %ebx
imull %eax, %ebx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x169cc(%rip), %rsi     # 0x203db
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1160
movq (%r14), %r15
testq %r15, %r15
je 0x9a41
leaq 0x169c3(%rip), %r14     # 0x203eb
movl (%r15), %edx
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x1160
movq 0x8(%r15), %r15
testq %r15, %r15
jne 0x9a28
leaq 0x16628(%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_O3/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 0x17af5(%rip), %rsi     # 0x215aa
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1160
movq (%r14), %r15
testq %r15, %r15
je 0x9ae7
leaq 0x16922(%rip), %r14     # 0x203f0
movl (%r15), %edx
movq %rbx, %rdi
movq %r14, %rsi
xorl %eax, %eax
callq 0x1160
movq 0x8(%r15), %r15
testq %r15, %r15
jne 0x9ace
movl $0xa, %edi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x1110
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/intSet.c
// Function: containsInt
char containsInt(struct IntSet* s, int i) {
	for (struct IntElement* e=s->first; e!=NULL; e=e->next) {
		if (e->value == i) {
			return 1;
		}
	}
	return 0;
}

// Assembly:
movq (%rdi), %rax
testq %rax, %rax
je 0x9b61
movl (%rax), %ecx
cmpl %esi, %ecx
je 0x9b5b
movq 0x8(%rax), %rax
testq %rax, %rax
jne 0x9b4c
cmpl %esi, %ecx
sete %al
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x10, %edi
callq 0x1190
movq $0x0, 0x8(%rax)
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_O3/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
movl $0x10, %edi
callq 0x1190
movq $0x0, 0x8(%rax)
movl %ebp, (%rax)
leaq 0x8(%rbx), %rcx
movq 0x8(%rbx), %rdx
testq %rdx, %rdx
je 0x9bf2
cmpl %ebp, (%rdx)
jle 0x9bfa
movq (%rbx), %rdx
cmpl %ebp, (%rdx)
jle 0x9bdd
movq %rdx, 0x8(%rax)
jmp 0x9bf5
movq %rdx, %rcx
movq 0x8(%rdx), %rdx
cmpl %ebp, (%rdx)
jle 0x9bdd
addq $0x8, %rcx
movq %rdx, 0x8(%rax)
jmp 0x9bfe
movq %rax, (%rcx)
movq %rbx, %rcx
jmp 0x9bfe
movq %rax, 0x8(%rdx)
movq %rax, (%rcx)
incq 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 %r15
pushq %r14
pushq %rbx
pushq %rax
movl %esi, %ebp
movq %rdi, %rbx
movq 0x8(%rdi), %r14
testq %r14, %r14
je 0x9c48
movl (%r14), %eax
cmpl %ebp, %eax
je 0x9c67
jge 0x9c72
movl $0x10, %edi
callq 0x1190
movq $0x0, 0x8(%rax)
movl %ebp, (%rax)
movq %rax, 0x8(%r14)
movq %rax, 0x8(%rbx)
jmp 0x9c63
movl $0x10, %edi
callq 0x1190
movq $0x0, 0x8(%rax)
movl %ebp, (%rax)
movq %rax, 0x8(%rbx)
movq %rax, (%rbx)
incq 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
jle 0x9c67
movq (%rbx), %r14
movl (%r14), %eax
cmpl %ebp, %eax
je 0x9c67
jle 0x9c92
movl $0x10, %edi
callq 0x1190
movl %ebp, (%rax)
movq %r14, 0x8(%rax)
jmp 0x9c60
jge 0x9c67
movq %r14, %r15
movq 0x8(%r14), %r14
cmpl %ebp, (%r14)
je 0x9c67
jle 0x9c94
movl $0x10, %edi
callq 0x1190
movl %ebp, (%rax)
movq %r14, 0x8(%rax)
movq %rax, 0x8(%r15)
jmp 0x9c63
// File: /workspace/github_c_makefile_star2_O3/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 0x9cfb
movq 0x8(%rax), %rcx
movq %rcx, (%rdi)
testq %rcx, %rcx
jne 0x9cef
movq $0x0, 0x8(%rdi)
decq 0x18(%rdi)
movq $0x0, 0x8(%rax)
retq
// File: /workspace/github_c_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, %r14
movq %rdi, %r15
movl $0x20, %edi
callq 0x1190
movq %rax, %rbx
movq $0x0, 0x18(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
movq (%r15), %r15
movq (%r14), %r14
testq %r15, %r15
setne %al
testq %r14, %r14
setne %cl
andb %al, %cl
cmpb $0x1, %cl
jne 0x9d9f
xorl %r12d, %r12d
xorl %r13d, %r13d
movl (%r15), %ebp
cmpl (%r14), %ebp
jne 0x9d89
movl $0x10, %edi
callq 0x1190
testq %r13, %r13
leaq 0x8(%r13), %rcx
movq $0x0, 0x8(%rax)
cmoveq %rbx, %rcx
movl %ebp, (%rax)
movq %rax, (%rcx)
movq %rax, 0x8(%rbx)
incq %r12
movq %r12, 0x18(%rbx)
movq 0x8(%r15), %r15
movq 0x8(%r14), %r14
movq %rax, %r13
jmp 0x9d95
jge 0x9d91
movq 0x8(%r15), %r15
jmp 0x9d95
movq 0x8(%r14), %r14
testq %r15, %r15
je 0x9d9f
testq %r14, %r14
jne 0x9d47
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x9dd5
movq (%rdi), %rax
movq 0x8(%rax), %rcx
testq %rcx, %rcx
je 0x9dcf
movl (%rax), %edx
movq %rcx, %rax
cmpl (%rcx), %edx
jle 0x9dbd
testq %rcx, %rcx
sete %al
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x9dfa
movq (%rdi), %rax
movq 0x8(%rax), %rcx
testq %rcx, %rcx
je 0x9df4
movl (%rax), %edx
movq %rcx, %rax
cmpl (%rcx), %edx
jl 0x9de2
testq %rcx, %rcx
sete %al
retq
nop
// File: /workspace/github_c_makefile_star2_O3/pwelke[P]GraphMiningTools/iterativeSubtreeIsomorphism.c
// Function: computeCharacteristic
int computeCharacteristic(struct SubtreeIsoDataStore data, struct Vertex* y, struct Vertex* u, struct Vertex* v, struct GraphPool* gp) {
	// TODO speedup by handling leaf case separately
	struct Graph* B = makeBipartiteInstanceFromVertices(data, y, u, v, gp);
	int sizeofMatching = bipartiteMatchingEvenMoreDirty(B);

	int nNeighbors = B->number;
	dumpGraph(gp, B);
	return (sizeofMatching == nNeighbors) ? 1 : 0;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x78, %rsp
movq %rcx, %rbx
movq %rdx, %r14
movq %rsi, %r15
movq %rdi, %rbp
movq 0xd0(%rsp), %rax
movq %rax, 0x70(%rsp)
movaps 0xb0(%rsp), %xmm0
movaps 0xc0(%rsp), %xmm1
movaps %xmm1, 0x60(%rsp)
movaps %xmm0, 0x50(%rsp)
movq %rsi, %rdi
callq 0x7c4e
movl %eax, %r12d
movq %r14, %rdi
callq 0x7c4e
movl 0x18(%rbp), %ecx
xorl %edx, %edx
cmpl 0x18(%r15), %ecx
setne %dl
subl %edx, %r12d
leal (%rax,%r12), %edi
movq %rbx, 0x38(%rsp)
movq %rbx, %rsi
callq 0x85e3
movq %rax, %r13
movq %r12, 0x28(%rsp)
movl %r12d, 0x8(%rax)
movq %r15, 0x40(%rsp)
movq 0x8(%r15), %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x9eba
movl 0x18(%rbp), %edx
movq 0x18(%rcx), %rsi
movl 0x18(%rsi), %esi
cmpl %edx, %esi
je 0x9eaf
movq 0x10(%r13), %rdi
cltq
movq (%rdi,%rax,8), %rdi
movl %esi, 0x20(%rdi)
movq (%rcx), %rsi
movq %rsi, (%rdi)
incl %eax
movq 0x8(%rcx), %rcx
testq %rcx, %rcx
jne 0x9e8f
cltq
movq 0x8(%r14), %rcx
testq %rcx, %rcx
je 0x9eeb
shlq $0x3, %rax
addq 0x10(%r13), %rax
movq 0x18(%rcx), %rdx
movl 0x18(%rdx), %edx
movq (%rax), %rsi
movl %edx, 0x20(%rsi)
movq (%rcx), %rdx
movq %rdx, (%rsi)
movq 0x8(%rcx), %rcx
addq $0x8, %rax
testq %rcx, %rcx
jne 0x9ecb
cmpl $0x0, 0x28(%rsp)
jle 0x9fdb
movl 0x28(%rsp), %eax
movq %rax, 0x30(%rsp)
movl (%r13), %eax
xorl %r12d, %r12d
cmpl %eax, 0x28(%rsp)
jge 0x9fcd
movq 0x10(%r13), %rax
movq (%rax,%r12,8), %rax
movslq 0x20(%rax), %rax
movq %rax, 0x48(%rsp)
movq 0x30(%rsp), %rbp
movq 0x10(%r13), %rcx
movq (%rcx,%rbp,8), %rax
movslq 0x20(%rax), %r15
movq 0x58(%rsp), %rbx
movq 0x10(%rbx), %rdx
movq (%rdx,%r15,8), %rdx
movl 0x1c(%rdx), %edx
cmpl 0x1c(%r14), %edx
jge 0x9fbe
movq (%rcx,%r12,8), %rcx
movq (%rcx), %rdi
movq (%rax), %rsi
callq 0x1bb34
testl %eax, %eax
jne 0x9fbe
movq 0x60(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x48(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
movq 0x10(%rbx), %rax
movq (%rax,%r15,8), %rdx
movq 0x70(%rsp), %rax
movq %rax, 0x20(%rsp)
movaps 0x50(%rsp), %xmm0
movaps 0x60(%rsp), %xmm1
movups %xmm1, 0x10(%rsp)
movups %xmm0, (%rsp)
movq 0x40(%rsp), %rdi
callq 0x16201
testl %eax, %eax
je 0x9fbe
movq 0x10(%r13), %rax
movq (%rax,%r12,8), %rdi
movq (%rax,%rbp,8), %rsi
movq 0x38(%rsp), %rax
movq 0x18(%rax), %rdx
callq 0x3468
incl 0x4(%r13)
incq %rbp
movl (%r13), %eax
cmpl %ebp, %eax
jg 0x9f26
incq %r12
cmpq 0x30(%rsp), %r12
jne 0x9f06
movq %r13, %rdi
callq 0x3762
xorl %ebp, %ebp
cmpl 0x8(%r13), %eax
sete %bpl
movq 0x38(%rsp), %rdi
movq %r13, %rsi
callq 0x14700
movl %ebp, %eax
addq $0x78, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xa053
movq %rax, %rdi
callq 0x37de
movl %eax, %ebp
movq %rbx, %rdi
callq 0x3cf6
movsbl %bpl, %eax
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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
leaq (,%r15,4), %rdi
callq 0x1190
testq %r15, %r15
jle 0xa25f
movq 0x10(%r14), %rcx
xorl %edx, %edx
movslq (%rbx,%rdx,4), %rsi
movq (%rcx,%rsi,8), %rdi
movl 0x20(%rdi), %edi
movl %edi, (%rax,%rsi,4)
incq %rdx
cmpq %rdx, %r15
jne 0xa249
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1bc66
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0xa223
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_O3/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)
movq $0x0, 0x20(%rdi)
movq %rsi, %rdi
xorl %esi, %esi
callq 0x1bc66
movq %rax, (%r14)
movq %rbx, 0x8(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x1619d
movq 0x8(%rbx), %rax
cmpl $0x0, (%rax)
jle 0xa8d9
xorl %r13d, %r13d
movq 0x10(%rax), %rax
movq (%rbx), %rcx
movslq (%rcx,%r13,4), %rcx
movq (%rax,%rcx,8), %r12
movq (%r12), %rdi
movq %r15, %rsi
callq 0x1bb34
testl %eax, %eax
jne 0xa8ca
movq %rbx, %rdi
movq %r14, %rsi
movq %r14, %rdx
movq %r12, %rcx
callq 0x16234
movl $0x1, 0x20(%rbx)
incq %r13
movq 0x8(%rbx), %rax
movslq (%rax), %rcx
cmpq %rcx, %r13
jl 0xa893
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl $0x2, %edi
movq %rdx, %rsi
callq 0x85e3
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
xorl %edi, %edi
movl $0x1, %esi
movq %r12, %rcx
movq %r14, %r8
callq 0x84a3
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 0xa6c6
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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
movl 0x8(%rsi), %esi
xorl %r13d, %r13d
testl %esi, %esi
jle 0xa9c4
xorl %ebp, %ebp
movq 0x10(%r15), %rax
movq (%rax,%rbp,8), %rdi
callq 0x344d
testb %al, %al
je 0xa9b8
incq %rbp
movslq 0x8(%r15), %rsi
cmpq %rsi, %rbp
jl 0xa999
jmp 0xa9c4
movq 0x10(%r15), %rax
movq (%rax,%rbp,8), %r13
movl 0x8(%r15), %esi
movq %r13, %rdi
callq 0x1bd39
movl 0x8(%r15), %eax
testl %eax, %eax
jle 0xaa06
xorl %r13d, %r13d
movq 0x10(%r15), %rcx
movq (%rcx,%r13,8), %rcx
cmpl $0x1, 0x1c(%rcx)
jne 0xa9fb
movl 0x20(%rcx), %esi
movl 0x18(%r14), %edx
movl 0x18(%rbx), %ecx
movq %r12, %rdi
callq 0x1625e
movl 0x8(%r15), %eax
incq %r13
movslq %eax, %rcx
cmpq %rcx, %r13
jl 0xa9d7
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xaa6b
movq %rdx, %r14
movslq (%rsi), %rsi
callq 0x16190
movq %rax, 0x18(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xaa89
movq 0x8(%rbx), %rax
movq 0x18(%rbx), %rdi
movl (%rax), %esi
callq 0x161f7
jmp 0xaa76
xorl %eax, %eax
cmpl $0x0, (%rsi)
sete %al
movl %eax, 0x20(%rbx)
movq $0x0, 0x18(%rbx)
movq %rbx, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x3c50
movq %rax, %rbp
movq %rbx, 0x28(%rsp)
movl $0x0, 0x20(%rbx)
movl (%r14), %ecx
testl %ecx, %ecx
jle 0xabd9
movl (%r15), %eax
xorl %esi, %esi
movq %r14, 0x30(%rsp)
testl %eax, %eax
jle 0xab9f
movq 0x10(%r14), %rax
movq 0x28(%rsp), %rcx
movq (%rcx), %rcx
movq %rsi, 0x38(%rsp)
movslq (%rcx,%rsi,4), %rcx
movq (%rax,%rcx,8), %r12
xorl %r14d, %r14d
movq 0x10(%r15), %rax
movq (%rax,%r14,8), %r13
movq (%r13), %rdi
movq (%r12), %rsi
callq 0x1bb34
testl %eax, %eax
jne 0xab83
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 0xa053
movq %rax, %rbp
movq %rax, %rdi
callq 0x3762
movl 0x8(%rbp), %ecx
cmpl %ecx, %eax
je 0xabb0
decl %ecx
cmpl %ecx, %eax
jne 0xab78
movq 0x28(%rsp), %rdi
movq %rbp, %rsi
movq %r13, %rdx
movq %r12, %rcx
callq 0xa976
movq %rbx, %rbp
movq %rbx, %rdi
callq 0x3cf6
incq %r14
movslq (%r15), %rax
cmpq %rax, %r14
jl 0xaafd
movq 0x30(%rsp), %r14
movl (%r14), %ecx
movq 0x38(%rsp), %rsi
incq %rsi
movslq %ecx, %rdx
cmpq %rdx, %rsi
jl 0xaad9
jmp 0xabd9
movq 0x28(%rsp), %r14
movq %r14, %rdi
movq %r13, %rsi
movq %r13, %rdx
movq %r12, %rcx
callq 0x16234
movl $0x1, 0x20(%r14)
movq %rbx, %rbp
movq %rbx, %rdi
callq 0x3cf6
movq %rbp, %rdi
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x3d51
// File: /workspace/github_c_makefile_star2_O3/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
movq $0x0, 0x20(%rsp)
movq %rdi, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
cmpl $0x0, (%rdi)
jle 0xac65
movq %rdx, %rbx
movq %rdi, %r15
xorl %esi, %esi
callq 0x1bc66
movq %rsp, %r12
movq %rax, (%r12)
movslq (%r15), %rdi
movslq (%r14), %rsi
callq 0x16190
movq %rax, 0x18(%r12)
movq %r12, %rdi
movq %rbx, %rsi
callq 0xaa89
movq 0x8(%r12), %rax
movq 0x18(%r12), %rdi
movl (%rax), %esi
callq 0x161f7
movq (%r12), %rdi
callq 0x1030
movl 0x20(%r12), %eax
jmp 0xac6e
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_O3/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
movq $0x0, 0x28(%rsp)
movq %rdi, 0x10(%rsp)
movq %rdx, 0x18(%rsp)
cmpl $0x0, (%rdi)
jle 0xacf7
movq %r8, %rbx
movq %rcx, %r14
movq %rdx, %r15
movq %rdi, %r12
movl 0x18(%rsi), %esi
callq 0x1bc66
leaq 0x8(%rsp), %r13
movq %rax, (%r13)
movslq (%r12), %rdi
movslq (%r15), %rsi
callq 0x16190
movq %rax, 0x18(%r13)
movq %r13, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xad0a
movq %rax, %rbx
movq 0x8(%r13), %rax
movq 0x18(%r13), %rdi
movl (%rax), %esi
callq 0x161f7
movq (%r13), %rdi
callq 0x1030
jmp 0xacf9
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_O3/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 0xaf0e
movq %rdx, %r14
movslq (%r12), %rsi
callq 0x16190
movq %rax, 0x18(%rbx)
movq 0x10(%r12), %rax
movq (%rax), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0xad0a
movq %rax, (%r14)
movq 0x8(%rbx), %rax
movq 0x18(%rbx), %rdi
movl (%rax), %esi
callq 0x161f7
jmp 0xaf1b
xorl %eax, %eax
cmpl $0x0, (%r12)
sete %al
movl %eax, 0x20(%rbx)
movq $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_O3/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, %rbx
movl (%rdi), %edi
movq %rdx, 0x8(%rsp)
movq %rdx, %rsi
callq 0x85e3
movq %rax, %r13
movq %r14, %rdi
callq 0x1498d
movq %rax, (%rsp)
movq %rbx, 0x10(%rsp)
movl 0x4(%rbx), %eax
testl %eax, %eax
jle 0xb047
xorl %r12d, %r12d
movq (%r15,%r12,8), %rdx
movq 0x10(%r13), %rcx
movq 0x10(%rdx), %rsi
movslq 0x18(%rsi), %rsi
movq (%rcx,%rsi,8), %rbp
movq 0x8(%rbp), %rsi
testq %rsi, %rsi
je 0xaf9f
movq 0x18(%rsi), %rbp
jmp 0xaf90
movq 0x18(%rdx), %rdx
movslq 0x18(%rdx), %rdx
movq (%rcx,%rdx,8), %rbx
movq 0x8(%rbx), %rcx
testq %rcx, %rcx
je 0xafba
movq 0x18(%rcx), %rbx
jmp 0xafab
cmpq %rbx, %rbp
je 0xb038
movq 0x10(%r14), %rdi
callq 0x141f1
movl 0x28(%rbp), %ecx
cmpl 0x28(%rbx), %ecx
jge 0xaff1
movq %rbp, 0x10(%rax)
movq %rbx, 0x18(%rax)
movq %rbp, %rdi
movq %rax, %rsi
callq 0x7cfe
movl 0x28(%rbp), %eax
cmpl 0x28(%rbx), %eax
jne 0xb017
addq $0x28, %rbx
jmp 0xb013
movq %rbx, 0x10(%rax)
movq %rbp, 0x18(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7cfe
movl 0x28(%rbp), %eax
cmpl 0x28(%rbx), %eax
jne 0xb017
addq $0x28, %rbp
movq %rbp, %rbx
incl %eax
movl %eax, (%rbx)
movq (%r15,%r12,8), %rdi
movq 0x10(%r14), %rsi
callq 0x7bec
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x8916
movq 0x10(%rsp), %rax
movl 0x4(%rax), %eax
incq %r12
movslq %eax, %rcx
cmpq %rcx, %r12
jl 0xaf7c
movq 0x8(%rsp), %rdi
movq %r13, %rsi
callq 0x14700
movq (%rsp), %rax
addq $0x18, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O3/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 %rbp
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %esi, %ebp
movq %rdi, %rbx
movslq %esi, %r12
leaq (,%r12,4), %r15
movq %r15, %rdi
callq 0x1190
movq %rax, %r14
movq %r15, %rdi
callq 0x1190
movq %rax, %r15
testl %r12d, %r12d
jle 0xb0bf
movl %ebp, %r12d
shlq $0x2, %r12
movq %r14, %rdi
movl $0xff, %esi
movq %r12, %rdx
callq 0x10d0
movq %r15, %rdi
xorl %esi, %esi
movq %r12, %rdx
callq 0x10d0
testq %rbx, %rbx
je 0xb10b
xorl %eax, %eax
movq (%rbx), %rcx
testq %rcx, %rcx
je 0xb100
movq 0x10(%rcx), %rdx
movslq 0x18(%rdx), %rdx
cmpl %eax, (%r14,%rdx,4)
jge 0xb0e4
movl %eax, (%r14,%rdx,4)
incl (%r15,%rdx,4)
movq 0x18(%rcx), %rdx
movslq 0x18(%rdx), %rdx
cmpl %eax, (%r14,%rdx,4)
jge 0xb0fa
movl %eax, (%r14,%rdx,4)
incl (%r15,%rdx,4)
movq 0x8(%rcx), %rcx
jmp 0xb0c9
incl %eax
movq 0x18(%rbx), %rbx
testq %rbx, %rbx
jne 0xb0c6
movq %r14, %rdi
callq 0x1030
movq %r15, %rax
popq %rbx
popq %r12
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xb23b
movq %rax, %r14
movl (%r15), %esi
movq %rax, %rdi
callq 0xb11f
movslq (%r15), %rcx
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testq %rcx, %rcx
jle 0xb21b
xorl %edx, %edx
movl (%rax,%rdx,4), %esi
cmpl %esi, %ebp
cmovlel %esi, %ebp
incq %rdx
cmpq %rdx, %rcx
jne 0xb20b
movq %rax, %rdi
callq 0x1030
movq %rbx, %rdi
movq %r14, %rsi
callq 0x14a56
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x141f1
movq %rax, %r14
movslq (%r15), %rax
testq %rax, %rax
jle 0xb2f1
movq 0x10(%r15), %rcx
xorl %edx, %edx
movq (%rcx,%rdx,8), %rsi
movl $0x0, 0x1c(%rsi)
incq %rdx
cmpq %rdx, %rax
jne 0xb268
testl %eax, %eax
jle 0xb2f1
xorl %r13d, %r13d
xorl %r12d, %r12d
movq 0x10(%r15), %rcx
movq (%rcx,%r13,8), %rdi
cmpl $0x0, 0x1c(%rdi)
jne 0xb2b8
movq 0x10(%rbx), %r8
movq %rdi, %rsi
xorl %edx, %edx
movq %r14, %rcx
movq %rbx, %r9
callq 0xb8b6
movq %r12, %rdi
movq %rax, %rsi
callq 0x883e
movq %rax, %r12
movl (%r15), %eax
incq %r13
movslq %eax, %rcx
cmpq %rcx, %r13
jl 0xb285
testq %r12, %r12
je 0xb2f1
movq 0x20(%r12), %rax
xorl %ecx, %ecx
movq %rcx, 0x18(%rax)
movq %rcx, 0x20(%r12)
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x14250
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x12b8
xorl %r12d, %r12d
jmp 0xb2d8
// File: /workspace/github_c_makefile_star2_O3/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 0xb23b
movq %rax, %r14
movl (%r15), %esi
movq %rax, %rdi
callq 0xb11f
movslq (%r15), %rcx
movl $0x7fffffff, %ebp       # imm = 0x7FFFFFFF
testq %rcx, %rcx
jle 0xb33a
xorl %edx, %edx
movl (%rax,%rdx,4), %esi
cmpl %esi, %ebp
cmovgel %esi, %ebp
incq %rdx
cmpq %rdx, %rcx
jne 0xb32a
movq %rax, %rdi
callq 0x1030
movq %rbx, %rdi
movq %r14, %rsi
callq 0x14a56
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xb23b
xorl %ebp, %ebp
testq %rax, %rax
je 0xb37a
movq %rax, %rcx
incl %ebp
movq 0x18(%rcx), %rcx
testq %rcx, %rcx
jne 0xb36f
movq %rbx, %rdi
movq %rax, %rsi
callq 0x14a56
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xb3ca
movq %rsi, %rbx
callq 0xb23b
xorl %ebp, %ebp
testq %rax, %rax
je 0xb3bd
movq %rax, %rcx
xorl %edx, %edx
cmpl $0x2, 0x10(%rcx)
setge %dl
addl %edx, %ebp
movq 0x18(%rcx), %rcx
testq %rcx, %rcx
jne 0xb3a9
movq %rbx, %rdi
movq %rax, %rsi
callq 0x14a56
jmp 0xb3cc
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq