LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x9600
movq %rax, %r15
xorl %ebp, %ebp
testq %rax, %rax
je 0x980a
movq %r15, %r13
movq %r13, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0xabfd
cmpb $0x1, %al
sbbl $-0x1, %ebp
movq 0x18(%r13), %r13
testq %r13, %r13
jne 0x97ee
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x9765
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_O1/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 0x9600
movq %rax, %r15
testq %rax, %rax
je 0x9887
movq %r14, (%rsp)
xorl %ebp, %ebp
movq %r15, %r13
xorl %r14d, %r14d
movq %r13, %rdi
movq %r12, %rsi
movq %rbx, %rdx
callq 0xabfd
cmpb $0x1, %al
sbbl $-0x1, %r14d
incl %ebp
movq 0x18(%r13), %r13
testq %r13, %r13
jne 0x9859
cvtsi2sd %r14d, %xmm1
cvtsi2sd %ebp, %xmm0
movq (%rsp), %r14
jmp 0x988f
xorpd %xmm1, %xmm1
xorpd %xmm0, %xmm0
divsd %xmm0, %xmm1
movsd %xmm1, (%rsp)
movq %r14, %rdi
movq %r15, %rsi
movq %rbx, %rdx
callq 0x9765
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_O1/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 0x9927
testb $0x1, %sil
je 0x991a
decl %esi
imull %edi, %ebx
jmp 0x9909
shrl %esi
callq 0x9903
imull %eax, %eax
imull %eax, %ebx
movl %ebx, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x10, %edi
callq 0x1190
movl $0x0, (%rax)
movq $0x0, 0x8(%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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
movl $0x20, %edi
callq 0x1190
movq $0x0, 0x18(%rax)
xorps %xmm0, %xmm0
movups %xmm0, (%rax)
popq %rcx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x169e0(%rip), %rsi     # 0x203db
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1160
movq (%r14), %r15
testq %r15, %r15
je 0x9a2d
leaq 0x169d7(%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 0x9a14
leaq 0x1663c(%rip), %rdi     # 0x20070
movl $0x2, %esi
movl $0x1, %edx
movq %rbx, %rcx
popq %rbx
popq %r14
popq %r15
jmp 0x1220
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/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 0x17b09(%rip), %rsi     # 0x215aa
movq %rbx, %rdi
xorl %eax, %eax
callq 0x1160
movq (%r14), %r15
testq %r15, %r15
je 0x9ad3
leaq 0x16936(%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 0x9aba
movl $0xa, %edi
movq %rbx, %rsi
popq %rbx
popq %r14
popq %r15
jmp 0x1110
// File: /workspace/github_c_makefile_star2_O1/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
xorl %edx, %edx
testq %rcx, %rcx
setne %dl
cmoveq %r14, %rcx
movq %rax, 0x8(%rcx)
movq %rax, (%r14,%rdx,8)
incq 0x18(%r14)
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x9bd6
cmpl %ebp, (%rdx)
jle 0x9bde
movq (%rbx), %rdx
cmpl %ebp, (%rdx)
jle 0x9bc1
movq %rdx, 0x8(%rax)
jmp 0x9bd9
movq %rdx, %rcx
movq 0x8(%rdx), %rdx
cmpl %ebp, (%rdx)
jle 0x9bc1
addq $0x8, %rcx
movq %rdx, 0x8(%rax)
jmp 0x9be2
movq %rax, (%rcx)
movq %rbx, %rcx
jmp 0x9be2
movq %rax, 0x8(%rdx)
movq %rax, (%rcx)
incq 0x18(%rbx)
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x9c2c
movl (%r14), %eax
cmpl %ebp, %eax
je 0x9c4b
jge 0x9c56
movl $0x10, %edi
callq 0x1190
movq $0x0, 0x8(%rax)
movl %ebp, (%rax)
movq %rax, 0x8(%r14)
movq %rax, 0x8(%rbx)
jmp 0x9c47
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 0x9c4b
movq (%rbx), %r14
movl (%r14), %eax
cmpl %ebp, %eax
je 0x9c4b
jle 0x9c76
movl $0x10, %edi
callq 0x1190
movl %ebp, (%rax)
movq %r14, 0x8(%rax)
jmp 0x9c44
jge 0x9c4b
movq %r14, %r15
movq 0x8(%r14), %r14
cmpl %ebp, (%r14)
je 0x9c4b
jle 0x9c78
movl $0x10, %edi
callq 0x1190
movq $0x0, 0x8(%rax)
movl %ebp, (%rax)
movq 0x8(%r15), %rcx
movq %rcx, 0x8(%rax)
movq %rax, 0x8(%r15)
jmp 0x9c47
// File: /workspace/github_c_makefile_star2_O1/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 0x9ced
movq 0x8(%rax), %rcx
movq %rcx, (%rdi)
testq %rcx, %rcx
jne 0x9ce1
movq $0x0, 0x8(%rdi)
decq 0x18(%rdi)
movq $0x0, 0x8(%rax)
retq
// File: /workspace/github_c_makefile_star2_O1/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, %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 0x9d59
movl (%r15), %esi
cmpl (%r14), %esi
jne 0x9d43
movq %rbx, %rdi
callq 0x9b46
movq 0x8(%r15), %r15
jmp 0x9d4b
jge 0x9d4b
movq 0x8(%r15), %r15
jmp 0x9d4f
movq 0x8(%r14), %r14
testq %r15, %r15
je 0x9d59
testq %r14, %r14
jne 0x9d2d
movq %rbx, %rax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x9d86
movq (%rdi), %rax
movq 0x8(%rax), %rcx
testq %rcx, %rcx
je 0x9d80
movl (%rax), %edx
movq %rcx, %rax
cmpl (%rcx), %edx
jle 0x9d6e
testq %rcx, %rcx
sete %al
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x9dab
movq (%rdi), %rax
movq 0x8(%rax), %rcx
testq %rcx, %rcx
je 0x9da5
movl (%rax), %edx
movq %rcx, %rax
cmpl (%rcx), %edx
jl 0x9d93
testq %rcx, %rcx
sete %al
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x7c22
movl %eax, %r12d
movq %r14, %rdi
callq 0x7c22
movl 0x18(%rbp), %ecx
xorl %edx, %edx
cmpl 0x18(%r15), %ecx
setne %dl
subl %edx, %r12d
leal (%rax,%r12), %edi
movq %rbx, 0x40(%rsp)
movq %rbx, %rsi
callq 0x8565
movq %rax, %r13
movq %r12, 0x30(%rsp)
movl %r12d, 0x8(%rax)
movq %r15, 0x48(%rsp)
movq 0x8(%r15), %rcx
xorl %eax, %eax
testq %rcx, %rcx
je 0x9e6a
movl 0x18(%rbp), %edx
movq 0x18(%rcx), %rsi
movl 0x18(%rsi), %esi
cmpl %edx, %esi
je 0x9e5f
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 0x9e3f
cltq
movq 0x8(%r14), %rcx
testq %rcx, %rcx
je 0x9e9b
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 0x9e7b
cmpl $0x0, 0x30(%rsp)
jle 0x9f85
movl 0x30(%rsp), %eax
movq %rax, 0x38(%rsp)
xorl %r12d, %r12d
movq 0x30(%rsp), %rax
cmpl (%r13), %eax
jge 0x9f77
movq 0x10(%r13), %rax
movq (%rax,%r12,8), %rax
movslq 0x20(%rax), %rbx
movq 0x38(%rsp), %rbp
movq 0x10(%r13), %rcx
movq (%rcx,%rbp,8), %rax
movslq 0x20(%rax), %r15
movq 0x58(%rsp), %rdx
movq 0x10(%rdx), %rdx
movq (%rdx,%r15,8), %rdx
movl 0x1c(%rdx), %edx
cmpl 0x1c(%r14), %edx
jge 0x9f6a
movq (%rcx,%r12,8), %rcx
movq (%rcx), %rdi
movq (%rax), %rsi
callq 0x1bc18
testl %eax, %eax
jne 0x9f6a
movq 0x58(%rsp), %rax
movq 0x60(%rsp), %rcx
movq 0x10(%rcx), %rcx
movq (%rcx,%rbx,8), %rsi
movq 0x10(%rax), %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 0x48(%rsp), %rdi
callq 0x16329
testl %eax, %eax
je 0x9f6a
movq 0x10(%r13), %rax
movq (%rax,%r12,8), %rdi
movq (%rax,%rbp,8), %rsi
movq 0x40(%rsp), %rax
movq 0x18(%rax), %rdx
callq 0x344f
incl 0x4(%r13)
incq %rbp
cmpl %ebp, (%r13)
jg 0x9ed2
incq %r12
cmpq 0x38(%rsp), %r12
jne 0x9eb2
movq %r13, %rdi
callq 0x373e
xorl %ebp, %ebp
cmpl 0x8(%r13), %eax
sete %bpl
movq 0x40(%rsp), %rdi
movq %r13, %rsi
callq 0x14832
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_O1/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 0x9ffd
movq %rax, %rdi
callq 0x37ce
movl %eax, %ebp
movq %rbx, %rdi
callq 0x3ce4
movsbl %bpl, %eax
addq $0x28, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xa207
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 0xa1f1
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x1bd4a
movq %rax, %r14
movq %rbx, %rdi
movq %rax, %rsi
callq 0xa1cb
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_O1/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)
movups %xmm0, (%rdi)
movq $0x0, 0x20(%rdi)
movq %rsi, %rdi
xorl %esi, %esi
callq 0x1bd4a
movq %rax, (%r14)
movq %rbx, 0x8(%r14)
movq %r14, %rax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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, 0x10(%rdi)
movups %xmm0, (%rdi)
movq $0x0, 0x20(%rdi)
movaps 0x30(%rsp), %xmm0
movups %xmm0, (%rdi)
movq %rsi, 0x10(%rdi)
movq 0x10(%rsi), %rax
movq (%rax), %r14
movq (%r14), %r15
callq 0x162c5
movq 0x8(%rbx), %rax
cmpl $0x0, (%rax)
jle 0xa8a4
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 0x1bc18
testl %eax, %eax
jne 0xa895
movq %rbx, %rdi
movq %r14, %rsi
movq %r14, %rdx
movq %r12, %rcx
callq 0x1635c
movl $0x1, 0x20(%rbx)
incq %r13
movq 0x8(%rbx), %rax
movslq (%rax), %rcx
cmpq %rcx, %r13
jl 0xa85e
movq %rbx, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x8565
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 0x8425
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 0xa67c
movq %rbx, %rax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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
cmpl $0x0, 0x8(%rsi)
jle 0xa982
xorl %r13d, %r13d
xorl %ebp, %ebp
movq 0x10(%r15), %rax
movq (%rax,%rbp,8), %rdi
callq 0x3434
testb %al, %al
je 0xa987
incq %rbp
movslq 0x8(%r15), %rax
cmpq %rax, %rbp
jl 0xa963
jmp 0xa98f
xorl %r13d, %r13d
jmp 0xa98f
movq 0x10(%r15), %rax
movq (%rax,%rbp,8), %r13
movl 0x8(%r15), %esi
movq %r13, %rdi
callq 0x1be23
cmpl $0x0, 0x8(%r15)
jle 0xa9d1
xorl %r13d, %r13d
movq 0x10(%r15), %rax
movq (%rax,%r13,8), %rax
cmpl $0x1, 0x1c(%rax)
jne 0xa9c5
movl 0x20(%rax), %esi
movl 0x18(%r14), %edx
movl 0x18(%rbx), %ecx
movq %r12, %rdi
callq 0x16386
incq %r13
movslq 0x8(%r15), %rax
cmpq %rax, %r13
jl 0xa9a5
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/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, 0x10(%rdi)
movups %xmm0, (%rdi)
movq $0x0, 0x20(%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 0xaa41
movq %rdx, %r14
movslq (%rsi), %rsi
callq 0x162b8
movq %rax, 0x18(%rbx)
movq %rbx, %rdi
movq %r14, %rsi
callq 0xaa5f
movq 0x8(%rbx), %rax
movq 0x18(%rbx), %rdi
movl (%rax), %esi
callq 0x1631f
jmp 0xaa4c
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_O1/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 %r14
pushq %rbx
subq $0x28, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movq %rdi, 0x8(%rsp)
movq %rsi, 0x10(%rsp)
cmpl $0x0, (%rdi)
jle 0xac73
movq %rdx, %rbx
xorl %esi, %esi
callq 0x1bd4a
movq %rsp, %r14
movq %rax, (%r14)
movq 0x8(%r14), %rax
movq 0x10(%r14), %rcx
movslq (%rax), %rdi
movslq (%rcx), %rsi
callq 0x162b8
movq %rax, 0x18(%r14)
movq %r14, %rdi
movq %rbx, %rsi
callq 0xaa5f
movq 0x8(%r14), %rax
movq 0x18(%r14), %rdi
movl (%rax), %esi
callq 0x1631f
movq (%r14), %rdi
callq 0x1030
jmp 0xac7f
xorl %eax, %eax
cmpl $0x0, (%rsi)
sete %al
movl %eax, 0x20(%rsp)
movb 0x20(%rsp), %al
addq $0x28, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbx
subq $0x30, %rsp
xorps %xmm0, %xmm0
movaps %xmm0, (%rsp)
movaps %xmm0, 0x10(%rsp)
movq $0x0, 0x20(%rsp)
movq %rdi, 0x8(%rsp)
movq %rdx, 0x10(%rsp)
cmpl $0x0, (%rdi)
jle 0xad0d
movq %r8, %rbx
movq %rcx, %r14
movl 0x18(%rsi), %esi
callq 0x1bd4a
movq %rsp, %r15
movq %rax, (%r15)
movq 0x8(%r15), %rax
movq 0x10(%r15), %rcx
movslq (%rax), %rdi
movslq (%rcx), %rsi
callq 0x162b8
movq %rax, 0x18(%r15)
movq %r15, %rdi
movq %r14, %rsi
movq %rbx, %rdx
callq 0xad28
movq %rax, %rbx
movq 0x8(%r15), %rax
movq 0x18(%r15), %rdi
movl (%rax), %esi
callq 0x1631f
movq (%r15), %rdi
callq 0x1030
jmp 0xad1b
xorl %eax, %eax
cmpl $0x0, (%rdx)
sete %al
movl %eax, 0x20(%rsp)
xorl %ebx, %ebx
movq %rbx, %rax
addq $0x30, %rsp
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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, 0x10(%rdi)
movups %xmm0, (%rdi)
movq $0x0, 0x20(%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 0xaf8d
movq %rdx, %r14
movslq (%r12), %rsi
callq 0x162b8
movq %rax, 0x18(%rbx)
movq 0x10(%r12), %rax
movq (%rax), %rsi
movq %rbx, %rdi
movq %r15, %rdx
callq 0xad28
movq %rax, (%r14)
movq 0x8(%rbx), %rax
movq 0x18(%rbx), %rdi
movl (%rax), %esi
callq 0x1631f
jmp 0xaf9a
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
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O1/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, %rbx
movq %rsi, %r15
movq %rdi, %r12
movl (%rdi), %edi
movq %rdx, 0x10(%rsp)
movq %rdx, %rsi
callq 0x8565
movq %rax, 0x8(%rsp)
movq %rbx, %r13
movq %rbx, %rdi
callq 0x14aae
movq %rax, (%rsp)
cmpl $0x0, 0x4(%r12)
jle 0xb0c9
xorl %r14d, %r14d
movq (%r15,%r14,8), %rcx
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rcx), %rdx
movslq 0x18(%rdx), %rdx
movq (%rax,%rdx,8), %rbx
movq 0x8(%rbx), %rdx
testq %rdx, %rdx
je 0xb025
movq 0x18(%rdx), %rbx
jmp 0xb016
movq 0x18(%rcx), %rcx
movslq 0x18(%rcx), %rcx
movq (%rax,%rcx,8), %rbp
movq 0x8(%rbp), %rax
testq %rax, %rax
je 0xb040
movq 0x18(%rax), %rbp
jmp 0xb031
cmpq %rbp, %rbx
je 0xb0b8
movq 0x10(%r13), %rdi
callq 0x1432b
movl 0x28(%rbx), %ecx
cmpl 0x28(%rbp), %ecx
jge 0xb077
movq %rbx, 0x10(%rax)
movq %rbp, 0x18(%rax)
movq %rbx, %rdi
movq %rax, %rsi
callq 0x7cd0
movl 0x28(%rbp), %eax
cmpl %eax, 0x28(%rbx)
jne 0xb09a
leaq 0x28(%rbp), %rcx
jmp 0xb096
movq %rbp, 0x10(%rax)
movq %rbx, 0x18(%rax)
movq %rbp, %rdi
movq %rax, %rsi
callq 0x7cd0
movl 0x28(%rbx), %eax
cmpl 0x28(%rbp), %eax
jne 0xb09a
leaq 0x28(%rbx), %rcx
incl %eax
movl %eax, (%rcx)
cmpq %rbp, %rbx
je 0xb0b8
movq (%r15,%r14,8), %rdi
movq 0x10(%r13), %rsi
callq 0x7bc0
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x88b9
incq %r14
movslq 0x4(%r12), %rax
cmpq %rax, %r14
jl 0xaffd
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x14832
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_O1/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 0xb143
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 0xb18f
xorl %eax, %eax
movq (%rbx), %rcx
testq %rcx, %rcx
je 0xb184
movq 0x10(%rcx), %rdx
movslq 0x18(%rdx), %rdx
cmpl %eax, (%r14,%rdx,4)
jge 0xb168
movl %eax, (%r14,%rdx,4)
incl (%r15,%rdx,4)
movq 0x18(%rcx), %rdx
movslq 0x18(%rdx), %rdx
cmpl %eax, (%r14,%rdx,4)
jge 0xb17e
movl %eax, (%r14,%rdx,4)
incl (%r15,%rdx,4)
movq 0x8(%rcx), %rcx
jmp 0xb14d
incl %eax
movq 0x18(%rbx), %rbx
testq %rbx, %rbx
jne 0xb14a
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_O1/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 0xb2bf
movq %rax, %r14
movl (%r15), %esi
movq %rax, %rdi
callq 0xb1a3
movslq (%r15), %rcx
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
testq %rcx, %rcx
jle 0xb29f
xorl %edx, %edx
movl (%rax,%rdx,4), %esi
cmpl %esi, %ebp
cmovlel %esi, %ebp
incq %rdx
cmpq %rdx, %rcx
jne 0xb28f
movq %rax, %rdi
callq 0x1030
movq %rbx, %rdi
movq %r14, %rsi
callq 0x14b75
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/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 0x1432b
movq %rax, %r14
movslq (%r15), %rax
testq %rax, %rax
jle 0xb2fb
movq 0x10(%r15), %rcx
xorl %edx, %edx
movq (%rcx,%rdx,8), %rsi
movl $0x0, 0x1c(%rsi)
incq %rdx
cmpq %rdx, %rax
jne 0xb2e8
cmpl $0x0, (%r15)
jle 0xb344
xorl %r13d, %r13d
xorl %r12d, %r12d
movq 0x10(%r15), %rax
movq (%rax,%r13,8), %rdi
cmpl $0x0, 0x1c(%rdi)
jne 0xb337
movq 0x10(%rbx), %r8
movq %rdi, %rsi
xorl %edx, %edx
movq %r14, %rcx
movq %rbx, %r9
callq 0xb931
movq %r12, %rdi
movq %rax, %rsi
callq 0x87c2
movq %rax, %r12
incq %r13
movslq (%r15), %rax
cmpq %rax, %r13
jl 0xb307
jmp 0xb347
xorl %r12d, %r12d
testq %r12, %r12
je 0xb375
movq 0x20(%r12), %rax
xorl %ecx, %ecx
movq %rcx, 0x18(%rax)
movq %rcx, 0x20(%r12)
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x1438e
movq %r12, %rax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
callq 0x12b8
jmp 0xb35c
// File: /workspace/github_c_makefile_star2_O1/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 0xb2bf
movq %rax, %r14
movl (%r15), %esi
movq %rax, %rdi
callq 0xb1a3
movslq (%r15), %rcx
movl $0x7fffffff, %ebp       # imm = 0x7FFFFFFF
testq %rcx, %rcx
jle 0xb3bb
xorl %edx, %edx
movl (%rax,%rdx,4), %esi
cmpl %esi, %ebp
cmovgel %esi, %ebp
incq %rdx
cmpq %rdx, %rcx
jne 0xb3ab
movq %rax, %rdi
callq 0x1030
movq %rbx, %rdi
movq %r14, %rsi
callq 0x14b75
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/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 0xb2bf
xorl %ebp, %ebp
testq %rax, %rax
je 0xb3fb
movq %rax, %rcx
incl %ebp
movq 0x18(%rcx), %rcx
testq %rcx, %rcx
jne 0xb3f0
movq %rbx, %rdi
movq %rax, %rsi
callq 0x14b75
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xb44b
movq %rsi, %rbx
callq 0xb2bf
xorl %ebp, %ebp
testq %rax, %rax
je 0xb43e
movq %rax, %rcx
xorl %edx, %edx
cmpl $0x2, 0x10(%rcx)
setge %dl
addl %edx, %ebp
movq 0x18(%rcx), %rcx
testq %rcx, %rcx
jne 0xb42a
movq %rbx, %rdi
movq %rax, %rsi
callq 0x14b75
jmp 0xb44d
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xb490
testq %rax, %rax
je 0xb487
movq %rax, %r14
xorl %ebp, %ebp
movq %r14, %rdi
movq %rbx, %rsi
callq 0xb40f
cmpl %ebp, %eax
cmovgl %eax, %ebp
movq 0x18(%r14), %r14
testq %r14, %r14
jne 0xb46c
jmp 0xb489
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/listComponents.c
// Function: listConnectedComponents
struct Graph* listConnectedComponents(struct Graph* g, struct GraphPool* gp) {
	struct Graph* components = NULL;
	int v;
	int componentNumber = 0;

	struct Graph* copy = getGraph(gp);
	setVertexNumber(copy, g->n);

	for (v=0; v<g->n; ++v) {
		g->vertices[v]->visited = -1;
	}
	for (v=0; v<g->n; ++v) {
		if (g->vertices[v]->visited == -1) {
			int m = -1;
			int w;
			struct Graph* currentComponent;

			m = markAndStoreConnectedComponent(g->vertices[v], copy, componentNumber);
			currentComponent = cloneInducedGraph(copy, gp);
			currentComponent->m = m / 2;
			currentComponent->next = components;
			components = currentComponent;
			
			for (w=0; w<copy->n; ++w) {
				copy->vertices[w] = NULL;
			}

			++componentNumber;
		}
	}
	dumpGraph(gp, copy);
	return components;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rdi, %r15
movq %rsi, (%rsp)
movq %rsi, %rdi
callq 0x147d7
movq %rax, %r14
movl (%r15), %esi
movq %rax, %rdi
callq 0x7e30
movslq (%r15), %rax
testq %rax, %rax
jle 0xb4d9
movq 0x10(%r15), %rcx
xorl %edx, %edx
movq (%rcx,%rdx,8), %rsi
movl $0xffffffff, 0x1c(%rsi) # imm = 0xFFFFFFFF
incq %rdx
cmpq %rdx, %rax
jne 0xb4c6
xorl %r12d, %r12d
cmpl $0x0, (%r15)
jle 0xb54f
xorl %ebx, %ebx
xorl %r13d, %r13d
movq 0x10(%r15), %rax
movq (%rax,%rbx,8), %rdi
cmpl $-0x1, 0x1c(%rdi)
jne 0xb542
movq %r14, %rsi
movl %r12d, %edx
callq 0xb8a7
movl %eax, %ebp
movq %r14, %rdi
movq (%rsp), %rsi
callq 0x807f
movl %ebp, %ecx
shrl $0x1f, %ecx
addl %ebp, %ecx
sarl %ecx
movl %ecx, 0x4(%rax)
movq %r13, 0x18(%rax)
movslq (%r14), %rcx
testq %rcx, %rcx
jle 0xb53c
xorl %edx, %edx
movq 0x10(%r14), %rsi
movq $0x0, (%rsi,%rdx,8)
incq %rdx
cmpq %rdx, %rcx
jne 0xb528
incl %r12d
movq %rax, %r13
incq %rbx
movslq (%r15), %rax
cmpq %rax, %rbx
jl 0xb4e7
jmp 0xb552
xorl %r13d, %r13d
movq (%rsp), %rdi
movq %r14, %rsi
callq 0x14832
movq %r13, %rax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/listComponents.c
// Function: getNumberOfBridges
int getNumberOfBridges(struct Graph* g, struct ShallowGraphPool* sgp) {
	struct ShallowGraph* biconnectedComponents = listBiconnectedComponents(g, sgp);
	struct ShallowGraph* comp;
	int bridgeNumber = 0;
	for (comp = biconnectedComponents; comp!=NULL; comp=comp->next) {
		if (comp->m == 1) {
			++bridgeNumber;
		}			
	}
	/* cleanup */
	dumpShallowGraphCycle(sgp, biconnectedComponents);
	return bridgeNumber;
}

// Assembly:
pushq %rbp
pushq %rbx
pushq %rax
movq %rsi, %rbx
callq 0xb2bf
xorl %ebp, %ebp
testq %rax, %rax
je 0xb599
movq %rax, %rcx
xorl %edx, %edx
cmpl $0x1, 0x10(%rcx)
sete %dl
addl %edx, %ebp
movq 0x18(%rcx), %rcx
testq %rcx, %rcx
jne 0xb585
movq %rbx, %rdi
movq %rax, %rsi
callq 0x14b75
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/listComponents.c
// Function: getNumberOfBridgeTrees
int getNumberOfBridgeTrees(struct Graph* g, struct ShallowGraphPool* sgp, struct GraphPool* gp) {
	struct ShallowGraph* h = listBiconnectedComponents(g, sgp);
	struct Graph* forest = partitionIntoForestAndCycles(h, g, gp, sgp);
	int nConnectedComponents = getAndMarkConnectedComponents(forest);
	dumpGraphList(gp, forest);
	return nConnectedComponents;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movq %rdx, %rbx
movq %rsi, %r14
movq %rdi, %r15
callq 0xb2bf
movq %rax, %rdi
movq %r15, %rsi
movq %rbx, %rdx
movq %r14, %rcx
callq 0xb5f8
movq %rax, %r14
movq %rax, %rdi
callq 0xb848
movl %eax, %ebp
movq %rbx, %rdi
movq %r14, %rsi
callq 0x148f4
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/listComponents.c
// Function: getAndMarkConnectedComponents
int getAndMarkConnectedComponents(struct Graph* g) {
	int componentNumber = 0;
	int v;
	for (v=0; v<g->n; ++v) {
		g->vertices[v]->visited = -1;
	}
	for (v=0; v<g->n; ++v) {
		if (g->vertices[v]->visited == -1) {
			markConnectedComponent(g->vertices[v], componentNumber);
			++componentNumber;
		}
	}
	return componentNumber;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
movq %rdi, %rbx
movslq (%rdi), %rax
testq %rax, %rax
jle 0xb870
movq 0x10(%rbx), %rcx
xorl %edx, %edx
movq (%rcx,%rdx,8), %rsi
movl $0xffffffff, 0x1c(%rsi) # imm = 0xFFFFFFFF
incq %rdx
cmpq %rdx, %rax
jne 0xb85d
cmpl $0x0, (%rbx)
jle 0xb89e
xorl %r14d, %r14d
xorl %ebp, %ebp
movq 0x10(%rbx), %rax
movq (%rax,%r14,8), %rdi
cmpl $-0x1, 0x1c(%rdi)
jne 0xb891
movl %ebp, %esi
callq 0xb8fe
incl %ebp
incq %r14
movslq (%rbx), %rax
cmpq %rax, %r14
jl 0xb87a
jmp 0xb8a0
xorl %ebp, %ebp
movl %ebp, %eax
popq %rbx
popq %r14
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/listComponents.c
// Function: markAndStoreConnectedComponent
int markAndStoreConnectedComponent(struct Vertex *v, struct Graph* copy, int component) {
	struct VertexList *index;
	int m = 0;

	/* mark vertex as visited */
	v->visited = component;
	// store pointer to vertex in copy graph
	copy->vertices[v->number] = v;

	/*recursive call for all neighbors that are not visited so far */
	for (index = v->neighborhood; index; index = index->next) {
		++m;
		if (index->endPoint->visited != component) {
			m += markAndStoreConnectedComponent(index->endPoint, copy, component);
		}
	}
	return m;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
pushq %rax
movl %edx, 0x1c(%rdi)
movq 0x10(%rsi), %rax
movslq 0x18(%rdi), %rcx
movq %rdi, (%rax,%rcx,8)
movq 0x8(%rdi), %r15
testq %r15, %r15
je 0xb8ef
movl %edx, %ebx
movq %rsi, %r14
xorl %ebp, %ebp
incl %ebp
movq 0x18(%r15), %rdi
cmpl %ebx, 0x1c(%rdi)
je 0xb8e4
movq %r14, %rsi
movl %ebx, %edx
callq 0xb8a7
addl %eax, %ebp
movq 0x8(%r15), %r15
testq %r15, %r15
jne 0xb8cd
jmp 0xb8f1
xorl %ebp, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/pwelke[P]GraphMiningTools/listComponents.c
// Function: markConnectedComponent
void markConnectedComponent(struct Vertex *v, int component) {
	struct VertexList *index;

	/* mark vertex as visited */
	v->visited = component;

	/*recursive call for all neighbors that are not visited so far */
	for (index = v->neighborhood; index; index = index->next) {
		if (index->endPoint->visited != component) {
			markConnectedComponent(index->endPoint, component);
		}
	}
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movl %esi, 0x1c(%rdi)
movq 0x8(%rdi), %r14
testq %r14, %r14
je 0xb929
movl %esi, %ebx
movq 0x18(%r14), %rdi
cmpl %ebx, 0x1c(%rdi)
je 0xb920
movl %ebx, %esi
callq 0xb8fe
movq 0x8(%r14), %r14
testq %r14, %r14
jne 0xb910
addq $0x8, %rsp
popq %rbx
popq %r14
retq