LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/subtreeIsomorphismSampling.c
// Function: subtreeIsomorphismSamplerWithProperMatching
char subtreeIsomorphismSamplerWithProperMatching(struct Graph* g, struct Graph* h, struct GraphPool* gp) {

	// we root h at a random vertex
	struct Vertex* currentRoot = h->vertices[rand() % h->n];
	// and select a random image vertex
	struct Vertex* rootImage = g->vertices[rand() % g->n];
	//	fprintf(stderr, "\nnew round: %i -> %i\n", currentRoot->number, rootEmbedding->number);

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

		// cleanup
		cleanupSubtreeIsomorphismSampler(h, g);
	}

	return foundIso;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
callq 0x1220
movq 0x38(%rsp), %rcx
cltd
idivl (%rcx)
movq 0x8(%rsp), %rax
movslq %edx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x28(%rsp)
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
callq 0x1220
movq 0x40(%rsp), %rcx
cltd
idivl (%rcx)
movq 0x10(%rsp), %rax
movslq %edx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x20(%rsp)
movb $0x0, 0x1f(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rdi
movq 0x20(%rsp), %rax
movq (%rax), %rsi
callq 0x2dcf0
cmpl $0x0, %eax
jne 0x2ea80
movq 0x20(%rsp), %rax
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movq 0x28(%rsp), %rax
movl %ecx, 0x1c(%rax)
movq 0x20(%rsp), %rax
movl $0x1, 0x1c(%rax)
movq 0x28(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x30(%rsp), %rdx
callq 0x2ea90
movb %al, 0x1f(%rsp)
movq 0x38(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x2e5c0
movb 0x1f(%rsp), %al
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/subtreeIsomorphismSampling.c
// Function: subtreeIsomorphismSamplerWithSampledMaximumMatching
int subtreeIsomorphismSamplerWithSampledMaximumMatching(struct Graph* g, struct Graph* h, struct GraphPool* gp, int computeEstimate) {

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


	int foundIso = 0;
	if (rootImage) {
		//	if (labelCmp(currentRoot->label, rootImage->label) == 0) {
		// if there is a candidate image we map the root to the image
		currentRoot->visited = rootImage->number + 1;
		rootImage->visited = 1;
		// and try to embed the rest of the tree h into g accordingly
		foundIso = recursiveSubtreeIsomorphismSamplerWithSampledMaximumMatching(currentRoot, g, gp, computeEstimate);

		// cleanup
		cleanupSubtreeIsomorphismSampler(h, g);
	}

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

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movl %ecx, 0x34(%rsp)
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
callq 0x1220
movq 0x40(%rsp), %rcx
cltd
idivl (%rcx)
movq 0x8(%rsp), %rax
movslq %edx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x28(%rsp)
movq 0x28(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x38(%rsp), %rax
movq 0x18(%rax), %rdx
leaq 0x24(%rsp), %rcx
callq 0x2edc0
movq %rax, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x2ed8f
movq 0x18(%rsp), %rax
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movq 0x28(%rsp), %rax
movl %ecx, 0x1c(%rax)
movq 0x18(%rsp), %rax
movl $0x1, 0x1c(%rax)
movq 0x28(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x38(%rsp), %rdx
movl 0x34(%rsp), %ecx
callq 0x2ef10
movl %eax, 0x14(%rsp)
movq 0x40(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0x2e5c0
cmpl $0x0, 0x34(%rsp)
je 0x2eda5
movl 0x14(%rsp), %eax
imull 0x24(%rsp), %eax
movl %eax, 0x54(%rsp)
jmp 0x2edad
movl 0x14(%rsp), %eax
movl %eax, 0x54(%rsp)
movl 0x54(%rsp), %eax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/subtreeIsomorphismSampling.c
// Function: getSuitableImage
static struct Vertex* getSuitableImage(struct Vertex* root, struct Graph* g, struct ListPool* lp, int* nCandidates) {
	*nCandidates = 0;
	struct VertexList* candidates = NULL;
	for (int v=0; v<g->n; ++v) {
		if (labelCmp(root->label, g->vertices[v]->label) == 0) {
			struct VertexList* tmp = getVertexList(lp);
			tmp->next = candidates;
			tmp->endPoint = g->vertices[v];

			candidates = tmp;
			++(*nCandidates);
		}
	}
	struct Vertex* image = NULL;
	if (*nCandidates > 0) {
		int index = rand() % (*nCandidates);
		struct VertexList* e = candidates;
		for (int i=0; i<index; ++i) {
			e=e->next;
		}
		image = e->endPoint;
		// garbage collection
		dumpVertexListLinearly(lp, candidates);
	}
	return image;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq 0x38(%rsp), %rax
movl $0x0, (%rax)
movq $0x0, 0x30(%rsp)
movl $0x0, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
movq 0x48(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x2ee8c
movq 0x50(%rsp), %rax
movq (%rax), %rdi
movq 0x48(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x2c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rsi
callq 0x2dcf0
cmpl $0x0, %eax
jne 0x2ee7a
movq 0x40(%rsp), %rdi
callq 0x1f310
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x48(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x2c(%rsp), %rcx
movq (%rax,%rcx,8), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x20(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x2ee7c
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x2edf4
movq $0x0, 0x18(%rsp)
movq 0x38(%rsp), %rax
cmpl $0x0, (%rax)
jle 0x2ef04
callq 0x1220
movq 0x38(%rsp), %rcx
cltd
idivl (%rcx)
movl %edx, 0x14(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0x14(%rsp), %eax
jge 0x2eee7
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x2eec2
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x1f4a0
movq 0x18(%rsp), %rax
addq $0x58, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/subtreeIsomorphismSampling.c
// Function: recursiveSubtreeIsomorphismSamplerWithSampledMaximumMatching
static int recursiveSubtreeIsomorphismSamplerWithSampledMaximumMatching(struct Vertex* parent, struct Graph* g, struct GraphPool* gp, int computeEstimate) {

	struct Vertex* parentImage = g->vertices[parent->visited - 1];

	int matchingSize;
	int n_matchings = 0;
	struct VertexList** maximumMatching = uniformBlockMaximumMatching(parent, parentImage, &matchingSize, &n_matchings, computeEstimate);

	// base case: if there are no children that need to be matched, although parent is not a leaf, we are happy
	if (maximumMatching == EMPTY_MATCHING) {
		return 1;
	}

	// is there a matching here covering all unmatched neighbors of parent?
	// if not, there is no subgraph iso here
	if (maximumMatching == NULL) {
		return 0;
	}

	// recurse to the matched vertices
	for (int i=0; i<matchingSize; ++i) {
		int embeddingWorked = recursiveSubtreeIsomorphismSamplerWithSampledMaximumMatching(maximumMatching[i]->endPoint, g, gp, computeEstimate);
		if (!embeddingWorked) {
			free(maximumMatching);
			return 0;
		} else {
			n_matchings *= embeddingWorked;
		}
	}

	// so far, we have been successful
	free(maximumMatching);
	if (computeEstimate) {
		return n_matchings;
	} else {
		return 1;
	}
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movl %ecx, 0x24(%rsp)
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x38(%rsp), %rcx
movl 0x1c(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x18(%rsp)
movl $0x0, 0x10(%rsp)
movq 0x38(%rsp), %rdi
movq 0x18(%rsp), %rsi
movl 0x24(%rsp), %r8d
leaq 0x14(%rsp), %rdx
leaq 0x10(%rsp), %rcx
callq 0x2f360
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0xf1d2(%rip), %rax      # 0x3e150
jne 0x2ef8d
movl $0x1, 0x44(%rsp)
jmp 0x2f034
cmpq $0x0, 0x8(%rsp)
jne 0x2efa2
movl $0x0, 0x44(%rsp)
jmp 0x2f034
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0x14(%rsp), %eax
jge 0x2f011
movq 0x8(%rsp), %rax
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x18(%rax), %rdi
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rdx
movl 0x24(%rsp), %ecx
callq 0x2ef10
movl %eax, (%rsp)
cmpl $0x0, (%rsp)
jne 0x2eff6
movq 0x8(%rsp), %rdi
callq 0x1030
movl $0x0, 0x44(%rsp)
jmp 0x2f034
movl (%rsp), %eax
imull 0x10(%rsp), %eax
movl %eax, 0x10(%rsp)
jmp 0x2f004
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x2efaa
movq 0x8(%rsp), %rdi
callq 0x1030
cmpl $0x0, 0x24(%rsp)
je 0x2f02c
movl 0x10(%rsp), %eax
movl %eax, 0x44(%rsp)
jmp 0x2f034
movl $0x1, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/subtreeIsomorphismSampling.c
// Function: compareLabeledNeighbors
static int compareLabeledNeighbors(const void* p1, const void* p2) {
	struct VertexList* e1 = *(struct VertexList**)p1;
	struct VertexList* e2 = *(struct VertexList**)p2;

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

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rsi
callq 0x2dcf0
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jne 0x2f74b
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rsi
callq 0x2dcf0
movl %eax, 0x34(%rsp)
jmp 0x2f753
movl 0xc(%rsp), %eax
movl %eax, 0x34(%rsp)
movl 0x34(%rsp), %eax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/subtreeIsomorphismSampling.c
// Function: getClassesArray
static inline int* getClassesArray(struct VertexList** neighbors, int deg) {
	int nClasses = 1;
	for (int i=0; i<deg-1; ++i) {
		if (compareLabeledNeighbors(&(neighbors[i]), &(neighbors[i+1])) != 0) {
			++nClasses;
		}
	}
	int* classesArray = malloc((nClasses + 1) * sizeof(int));
	classesArray[0] = nClasses;
	int classCounter = 1;
	for (int i=0; i<deg-1; ++i) {
		if (compareLabeledNeighbors(&(neighbors[i]), &(neighbors[i+1])) != 0) {
			classesArray[classCounter] = i + 1;
			++classCounter;
		}
	}
	assert(classCounter == nClasses);

	classesArray[nClasses] = deg;
	return classesArray;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl $0x1, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movl 0x1c(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x2f7d6
movq 0x20(%rsp), %rdi
movslq 0x14(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq 0x20(%rsp), %rsi
movl 0x14(%rsp), %eax
addl $0x1, %eax
cltq
shlq $0x3, %rax
addq %rax, %rsi
callq 0x2f6e0
cmpl $0x0, %eax
je 0x2f7c7
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x2f7c9
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x2f77d
movl 0x18(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x2, %rdi
callq 0x1170
movq %rax, 0x8(%rsp)
movl 0x18(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, (%rax)
movl $0x1, 0x4(%rsp)
movl $0x0, (%rsp)
movl (%rsp), %eax
movl 0x1c(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x2f86f
movq 0x20(%rsp), %rdi
movslq (%rsp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq 0x20(%rsp), %rsi
movl (%rsp), %eax
addl $0x1, %eax
cltq
shlq $0x3, %rax
addq %rax, %rsi
callq 0x2f6e0
cmpl $0x0, %eax
je 0x2f862
movl (%rsp), %edx
addl $0x1, %edx
movq 0x8(%rsp), %rax
movslq 0x4(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x2f864
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0x2f808
movl 0x1c(%rsp), %edx
movq 0x8(%rsp), %rax
movslq 0x18(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/subtreeIsomorphismSampling.c
// Function: shuffleInClasses
static void shuffleInClasses(struct VertexList** imageNeighbors, int* imageNeighborClasses) {
	int startIdx = 0;
	for (int i=1; i<imageNeighborClasses[0] + 1; ++i) {
		int size = imageNeighborClasses[i] - startIdx;
		shuffle(&(imageNeighbors[startIdx]), size);
		startIdx = imageNeighborClasses[i];
	}
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl $0x1, 0x10(%rsp)
movl 0x10(%rsp), %eax
movq 0x18(%rsp), %rcx
movl (%rcx), %ecx
addl $0x1, %ecx
cmpl %ecx, %eax
jge 0x2f90e
movq 0x18(%rsp), %rax
movslq 0x10(%rsp), %rcx
movl (%rax,%rcx,4), %eax
subl 0x14(%rsp), %eax
movl %eax, 0xc(%rsp)
movq 0x20(%rsp), %rdi
movslq 0x14(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movslq 0xc(%rsp), %rsi
callq 0x2b0b0
movq 0x18(%rsp), %rax
movslq 0x10(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0x14(%rsp)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x2f8ae
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/subtreeIsomorphismSampling.c
// Function: n_max_matchings_complete
static int n_max_matchings_complete(int A, int B) {

	int a = min(A, B);
	int b = max(A, B);
	int c = 1;

	if (a != 0) {
		for (int i=b-a+1; i<=b; ++i) {
			c *= i;
		}
	}

	return c;
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movl %esi, 0x10(%rsp)
movl 0x14(%rsp), %edi
movl 0x10(%rsp), %esi
callq 0xda10
movl %eax, 0xc(%rsp)
movl 0x14(%rsp), %edi
movl 0x10(%rsp), %esi
callq 0xda40
movl %eax, 0x8(%rsp)
movl $0x1, 0x4(%rsp)
cmpl $0x0, 0xc(%rsp)
je 0x2f98d
movl 0x8(%rsp), %eax
subl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
movl (%rsp), %eax
cmpl 0x8(%rsp), %eax
jg 0x2f98b
movl (%rsp), %eax
imull 0x4(%rsp), %eax
movl %eax, 0x4(%rsp)
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0x2f96b
jmp 0x2f98d
movl 0x4(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/supportSet.c
// Function: appendSupportSetElement
void appendSupportSetElement(struct SupportSet* s, struct SupportSetElement* e) {
	if (s->last != NULL) {
		s->last->next = e;
		s->last = e;
	} else {
		s->first = s->last = e;
	}
	// // previously: count each embedding exactly once
	// s->size += 1;
	// count the values that the embedding operator reports
	s->size += e->data.foundIso;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x2f9d8
movq -0x10(%rsp), %rcx
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
jmp 0x2f9ee
movq -0x10(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rsp), %rax
movq %rcx, (%rax)
movq -0x10(%rsp), %rax
movslq 0x20(%rax), %rcx
movq -0x8(%rsp), %rax
addq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/supportSet.c
// Function: pushSupportSetElement
void pushSupportSetElement(struct SupportSet* s, struct SupportSetElement* e) {
	if (s->first != NULL) {
		e->next = s->first;
		s->first = e;
	} else {
		s->first = s->last = e;
	}
	// // previously: count each embedding exactly once
	// s->size += 1;
	// count the values that the embedding operator reports
	s->size += e->data.foundIso;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
cmpq $0x0, (%rax)
je 0x2fa95
movq -0x8(%rsp), %rax
movq (%rax), %rcx
movq -0x10(%rsp), %rax
movq %rcx, 0x28(%rax)
movq -0x10(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, (%rax)
jmp 0x2faab
movq -0x10(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rsp), %rax
movq %rcx, (%rax)
movq -0x10(%rsp), %rax
movslq 0x20(%rax), %rcx
movq -0x8(%rsp), %rax
addq 0x18(%rax), %rcx
movq %rcx, 0x18(%rax)
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/supportSet.c
// Function: popSupportSetElement
struct SupportSetElement* popSupportSetElement(struct SupportSet* s) {
	struct SupportSetElement* e = s->first;
	if (s->first != NULL) {
		s->first = e->next;
		s->size -= e->data.foundIso;
	}
	return e;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rsp)
movq -0x8(%rsp), %rax
cmpq $0x0, (%rax)
je 0x2fb67
movq -0x10(%rsp), %rax
movq 0x28(%rax), %rcx
movq -0x8(%rsp), %rax
movq %rcx, (%rax)
movq -0x10(%rsp), %rax
movslq 0x20(%rax), %rdx
movq -0x8(%rsp), %rax
movq 0x18(%rax), %rcx
subq %rdx, %rcx
movq %rcx, 0x18(%rax)
movq -0x10(%rsp), %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/supportSet.c
// Function: popSupportSetData
struct SubtreeIsoDataStore popSupportSetData(struct SupportSet *s) {
	struct SupportSetElement* e = popSupportSetElement(s);
	struct SubtreeIsoDataStore data = e->data;
	free(e);
	return data;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, 0x10(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x2fb20
movq 0x8(%rsp), %rdi
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rsi
movl $0x28, %edx
callq 0x1150
movq 0x18(%rsp), %rdi
callq 0x1030
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/supportSet.c
// Function: printSupportSet
void printSupportSet(struct SupportSet* l, FILE* out) {
	fprintf(out, "%zu elements: [", l->size);
	for (struct SupportSetElement* i=l->first; i!=NULL; i=i->next) {
		fprintf(out, "%i, ", i->data.g->number);
	}
	fprintf(out, "]\n");

}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdx
leaq 0x5850(%rip), %rsi      # 0x35433
movb $0x0, %al
callq 0x1140
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x2fc29
movq 0x8(%rsp), %rdi
movq (%rsp), %rax
movq 0x8(%rax), %rax
movl 0x8(%rax), %edx
leaq 0x582f(%rip), %rsi      # 0x35443
movb $0x0, %al
callq 0x1140
movq (%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, (%rsp)
jmp 0x2fbf6
movq 0x8(%rsp), %rdi
leaq 0x6bb2(%rip), %rsi      # 0x367e7
movb $0x0, %al
callq 0x1140
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/supportSet.c
// Function: printSupportSetSparse
void printSupportSetSparse(struct SupportSet* l, FILE* out) {
	fprintf(out, "%i:", l->first->data.h->number);
	for (struct SupportSetElement* e=l->first; e!=NULL; e=e->next) {
		fprintf(out, " %i", e->data.g->number);
	}
	fprintf(out, "\n");
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movl 0x8(%rax), %edx
leaq 0x57d5(%rip), %rsi      # 0x3544e
movb $0x0, %al
callq 0x1140
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x2fcbf
movq 0x8(%rsp), %rdi
movq (%rsp), %rax
movq 0x8(%rax), %rax
movl 0x8(%rax), %edx
leaq 0x6949(%rip), %rsi      # 0x365f3
movb $0x0, %al
callq 0x1140
movq (%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, (%rsp)
jmp 0x2fc8c
movq 0x8(%rsp), %rdi
leaq 0x53ea(%rip), %rsi      # 0x350b5
movb $0x0, %al
callq 0x1140
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/supportSet.c
// Function: dumpSupportSetElements
void dumpSupportSetElements(struct SupportSetElement* e) {
	if (e->next != NULL) {
		dumpSupportSetElements(e->next);
	}

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

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
cmpq $0x0, 0x28(%rax)
je 0x2fdbd
movq (%rsp), %rax
movq 0x28(%rax), %rdi
callq 0x2fda0
movq (%rsp), %rax
movq 0x18(%rax), %rdi
movq (%rsp), %rax
movq 0x8(%rax), %rax
movl (%rax), %esi
callq 0x22fa0
movq (%rsp), %rdi
callq 0x1030
popq %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/supportSet.c
// Function: dumpSupportSetElementsWithPostorder
void dumpSupportSetElementsWithPostorder(struct SupportSetElement* e, struct GraphPool* gp) {
	if (e->next != NULL) {
		dumpSupportSetElementsWithPostorder(e->next, gp);
	}

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

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x28(%rax)
je 0x2fe3d
movq 0x10(%rsp), %rax
movq 0x28(%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0x2fe10
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movl (%rax), %esi
callq 0x22fa0
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0x1fb30
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x1030
movq 0x10(%rsp), %rdi
callq 0x1030
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/supportSet.c
// Function: intersectTwoSupportSets
struct SupportSet* intersectTwoSupportSets(struct SupportSet* l1, struct SupportSet* l2) {
	struct SupportSet* supportList = getSupportSet();

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

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

}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
callq 0x2fd20
movq %rax, 0x40(%rsp)
movq 0x50(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x48(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x30(%rsp)
xorl %eax, %eax
cmpq $0x0, 0x38(%rsp)
movb %al, 0x2f(%rsp)
je 0x2ff5d
cmpq $0x0, 0x30(%rsp)
setne %al
movb %al, 0x2f(%rsp)
movb 0x2f(%rsp), %al
testb $0x1, %al
jne 0x2ff6a
jmp 0x30009
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rax
movl 0x8(%rax), %eax
movq 0x30(%rsp), %rcx
movq 0x8(%rcx), %rcx
cmpl 0x8(%rcx), %eax
jne 0x2ffca
movq 0x40(%rsp), %rdi
movq 0x38(%rsp), %rcx
movq 0x20(%rcx), %rdx
movq %rsp, %rax
movq %rdx, 0x20(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x2fa10
movq 0x38(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x30(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0x30004
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rax
movl 0x8(%rax), %eax
movq 0x30(%rsp), %rcx
movq 0x8(%rcx), %rcx
cmpl 0x8(%rcx), %eax
jge 0x2fff4
movq 0x38(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x38(%rsp)
jmp 0x30002
movq 0x30(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0x30004
jmp 0x2ff42
movq 0x40(%rsp), %rax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/supportSet.c
// Function: intersectSupportSets
struct SupportSet* intersectSupportSets(struct SupportSet* aprioriList) {
	if (aprioriList == NULL) {
		return NULL;
	}
	if (aprioriList->next == NULL) {
		return intersectTwoSupportSets(aprioriList, aprioriList); // copy
	}

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

	return intersection;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
jne 0x3003f
movq $0x0, 0x20(%rsp)
jmp 0x300d3
movq 0x18(%rsp), %rax
cmpq $0x0, 0x10(%rax)
jne 0x30061
movq 0x18(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x2ff10
movq %rax, 0x20(%rsp)
jmp 0x300d3
movq 0x18(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0x2ff10
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x300c9
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x2ff10
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
callq 0x2fd70
movq (%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x3008b
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/supportSet.c
// Function: isSortedSupportSetOnPatterns
char isSortedSupportSetOnPatterns(struct SupportSet* l) {
	if (l->size < 2) {
		return 1;
	}
	for (struct SupportSet* e=l; e->next!=NULL; e=e->next) {
		if (e->first->data.h->number >= e->next->first->data.h->number) {
			return 0;
		}
	}
	return 1;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq -0x10(%rsp), %rax
cmpq $0x2, 0x18(%rax)
jae 0x300f8
movb $0x1, -0x1(%rsp)
jmp 0x30150
movq -0x10(%rsp), %rax
movq %rax, -0x18(%rsp)
movq -0x18(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x3014b
movq -0x18(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movl 0x8(%rax), %eax
movq -0x18(%rsp), %rcx
movq 0x10(%rcx), %rcx
movq (%rcx), %rcx
movq 0x10(%rcx), %rcx
cmpl 0x8(%rcx), %eax
jl 0x30139
movb $0x0, -0x1(%rsp)
jmp 0x30150
jmp 0x3013b
movq -0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rsp)
jmp 0x30102
movb $0x1, -0x1(%rsp)
movb -0x1(%rsp), %al
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/supportSet.c
// Function: getSupportSetsOfPatterns
struct SupportSet* getSupportSetsOfPatterns(struct SupportSet* allSupportSets, struct IntSet* patternIds) {
	assert(allSupportSets != NULL);
	assert(patternIds != NULL);
	assert(isSortedUniqueIntSet(patternIds));
	assert(isSortedSupportSetOnPatterns(allSupportSets));

	struct SupportSet* selectedSupportSets = NULL;

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

	size_t assert_Found = 0;

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

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

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

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

}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq $0x0, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x28(%rsp)
movq 0x38(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
xorl %eax, %eax
cmpq $0x0, 0x28(%rsp)
movb %al, 0xf(%rsp)
je 0x301b2
cmpq $0x0, 0x20(%rsp)
setne %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x301bf
jmp 0x30267
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movl 0x8(%rax), %eax
movq 0x20(%rsp), %rcx
cmpl (%rcx), %eax
jne 0x3022a
movq 0x28(%rsp), %rdi
callq 0x30280
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x18(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x18(%rsp)
jmp 0x30262
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movl 0x8(%rax), %eax
movq 0x20(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x30252
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x28(%rsp)
jmp 0x30260
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x30262
jmp 0x30197
movq 0x30(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/supportSet.c
// Function: shallowCopySupportSet
struct SupportSet* shallowCopySupportSet(struct SupportSet* a) {
	struct SupportSet* copy = getSupportSet();
	copy->first = a->first;
	copy->last = a->last;
	copy->patternId = a->patternId;
	copy->size = a->size;
	return copy;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
callq 0x2fd20
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
movl 0x20(%rax), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x20(%rax)
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/supportSet.c
// Function: supportSetChangeHead
struct SupportSet* supportSetChangeHead(struct SupportSet* parentSupportSets, int parentIdToKeep) {
	assert(parentSupportSets != NULL);

	// don't change anything and return fast if list head is already correct
	if (parentSupportSets->first->data.h->number == parentIdToKeep) {
		return parentSupportSets;
	}
	for (struct SupportSet* e=parentSupportSets; e->next!=NULL; e=e->next) {
		if (e->next->first->data.h->number == parentIdToKeep) {
			// remove matching element from its position in the list
			struct SupportSet* match = e->next;
			e->next = e->next->next;
			// push matching element to head of list
			match->next = parentSupportSets;
			parentSupportSets = match;
			break; // stop searching for the list
		}
	}

	// first element is now correct
	assert(parentSupportSets->first->data.h->number == parentIdToKeep);

	return parentSupportSets;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movl 0x8(%rax), %eax
cmpl -0x14(%rsp), %eax
jne 0x3031d
movq -0x10(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0x303a6
movq -0x10(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x3039c
movq -0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movl 0x8(%rax), %eax
cmpl -0x14(%rsp), %eax
jne 0x3038a
movq -0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rsp)
movq -0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rcx
movq -0x20(%rsp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rsp), %rcx
movq -0x28(%rsp), %rax
movq %rcx, 0x10(%rax)
movq -0x28(%rsp), %rax
movq %rax, -0x10(%rsp)
jmp 0x3039c
jmp 0x3038c
movq -0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rsp)
jmp 0x30327
movq -0x10(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/supportSet.c
// Function: appendSupportSets
struct SupportSet* appendSupportSets(struct SupportSet* front, struct SupportSet* back) {
	struct SupportSet* tmp; 
	if (front) {
		for (tmp=front; tmp->next != NULL; tmp=tmp->next);
		tmp->next = back;
	} else {
		front = back;
	}
	return front;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
cmpq $0x0, -0x8(%rsp)
je 0x303fa
movq -0x8(%rsp), %rax
movq %rax, -0x18(%rsp)
movq -0x18(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x303ea
jmp 0x303da
movq -0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rsp)
jmp 0x303cc
movq -0x10(%rsp), %rcx
movq -0x18(%rsp), %rax
movq %rcx, 0x10(%rax)
jmp 0x30404
movq -0x10(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/supportSet.c
// Function: popSupportSet
struct SupportSet* popSupportSet(struct SupportSet** s) {
	struct SupportSet* head = (*s);
	(*s) = (*s)->next;
	head->next = NULL;
	return head;
}

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

	root->lowPoint = value;

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

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

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0x1c(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x20(%rax)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x304e4
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movl 0x20(%rax), %eax
cmpl 0x1c(%rsp), %eax
jle 0x304d2
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
movl 0x1c(%rsp), %esi
addl $0x1, %esi
callq 0x30450
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x20(%rax)
movl 0x8(%rsp), %eax
cmpl 0xc(%rsp), %eax
jle 0x304d0
movl 0x8(%rsp), %eax
movl %eax, 0xc(%rsp)
jmp 0x304d2
jmp 0x304d4
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x3047f
movl 0xc(%rsp), %eax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/treeCenter.c
// Function: treeCenter
int* treeCenter(struct Graph* tree) {
	int* centers = malloc(3 * sizeof(int));
	int i;

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

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0xc, %edi
callq 0x1170
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpl $0x3, (%rax)
jge 0x307ba
movq 0x10(%rsp), %rax
cmpl $0x1, (%rax)
jne 0x30795
movq 0x8(%rsp), %rax
movl $0x2, (%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0x4(%rax)
jmp 0x307b8
movq 0x8(%rsp), %rax
movl $0x3, (%rax)
movq 0x8(%rsp), %rax
movl $0x0, 0x4(%rax)
movq 0x8(%rsp), %rax
movl $0x1, 0x8(%rax)
jmp 0x3082e
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x307f5
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movl $0x7fffffff, 0x20(%rax) # imm = 0x7FFFFFFF
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x307c2
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rdi
xorl %esi, %esi
callq 0x30450
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rsi
movq 0x8(%rsp), %r8
xorl %ecx, %ecx
movl %ecx, %edx
callq 0x304f0
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/treeCenter.c
// Function: computeDistanceToCenter
int computeDistanceToCenter(struct Graph* g, struct ShallowGraphPool* sgp) {

	struct ShallowGraph* queue = getShallowGraph(sgp);

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

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

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

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

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

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0x1fe70
movq %rax, 0x30(%rsp)
movq 0x40(%rsp), %rdi
callq 0x30750
movq %rax, 0x28(%rsp)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
movq 0x40(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x308a7
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x24(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movl $0xffffffff, 0x20(%rax) # imm = 0xFFFFFFFF
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x30874
movl $0x1, 0x20(%rsp)
movl 0x20(%rsp), %eax
movq 0x28(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x30915
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x28(%rsp), %rcx
movslq 0x20(%rsp), %rdx
movslq (%rcx,%rdx,4), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
callq 0x32870
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x28(%rsp), %rcx
movslq 0x20(%rsp), %rdx
movslq (%rcx,%rdx,4), %rcx
movq (%rax,%rcx,8), %rax
movl $0x0, 0x20(%rax)
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x308af
movq 0x28(%rsp), %rdi
callq 0x1030
movl $0x0, 0x1c(%rsp)
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x328c0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x309d0
movq 0x10(%rsp), %rax
movl 0x20(%rax), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x309b5
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
cmpl $-0x1, 0x20(%rax)
jne 0x309a3
movl 0x1c(%rsp), %ecx
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movl %ecx, 0x20(%rax)
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x30(%rsp), %rsi
movq 0x38(%rsp), %rdx
callq 0x32870
jmp 0x309a5
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x30964
jmp 0x309b7
movq 0x30(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0x328c0
movq %rax, 0x10(%rsp)
jmp 0x3093b
movq 0x38(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x1ff70
movl 0x1c(%rsp), %eax
subl $0x1, %eax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/treeEnumeration.c
// Function: extendPatternAllWays
struct Graph* extendPatternAllWays(struct Graph* g, struct ShallowGraph* candidateEdges, struct GraphPool* gp) {
	struct Graph* rho = NULL;
	struct VertexList* e;
	for (e=candidateEdges->edges; e!=NULL; e=e->next) {
		int v;
		for (v=0; v<g->n; ++v) {
			/* if the labels are compatible */
			if (strcmp(g->vertices[v]->label, e->startPoint->label) == 0) {
				struct Graph* h = refinementGraph(g, v, e, gp);
				h->next = rho;
				rho = h;
			}
		}
	}
	return rho;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x30d6b
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x30(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x30d56
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rsi
callq 0x1120
cmpl $0x0, %eax
jne 0x30d47
movq 0x30(%rsp), %rdi
movl 0xc(%rsp), %esi
movq 0x10(%rsp), %rdx
movq 0x20(%rsp), %rcx
callq 0x309f0
movq %rax, (%rsp)
movq 0x18(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x18(%rax)
movq (%rsp), %rax
movq %rax, 0x18(%rsp)
jmp 0x30d49
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x30cdd
jmp 0x30d58
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x30cc9
movq 0x18(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/treeEnumeration.c
// Function: extendPatternOnOuterShells
struct Graph* extendPatternOnOuterShells(struct Graph* g, struct ShallowGraph* candidateEdges, struct GraphPool* gp, struct ShallowGraphPool* sgp) {

	struct Graph* rho = NULL;

	// if v->lowPoint >= outershell then we extend on v
	int outerShell = computeDistanceToCenter(g, sgp) - 1;

	// add refinement edges only at outer shell vertices
	for (int v=0; v<g->n; ++v) {
		if (g->vertices[v]->lowPoint >= outerShell) {
			for (struct VertexList* e=candidateEdges->edges; e!=NULL; e=e->next) {
				/* if the labels are compatible */
				if (strcmp(g->vertices[v]->label, e->startPoint->label) == 0) {
					struct Graph* h = refinementGraph(g, v, e, gp);
					h->next = rho;
					rho = h;
				}
			}
		}
	}
	return rho;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x40(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x30840
subl $0x1, %eax
movl %eax, 0x1c(%rsp)
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
movq 0x40(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x3105a
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movl 0x20(%rax), %eax
cmpl 0x1c(%rsp), %eax
jl 0x31048
movq 0x38(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x31046
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x18(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rsi
callq 0x1120
cmpl $0x0, %eax
jne 0x31034
movq 0x40(%rsp), %rdi
movl 0x18(%rsp), %esi
movq 0x10(%rsp), %rdx
movq 0x30(%rsp), %rcx
callq 0x309f0
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x31036
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x30fcc
jmp 0x31048
jmp 0x3104a
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x30f8f
movq 0x20(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/treeEnumeration.c
// Function: basicFilter
struct Graph* basicFilter(struct Graph* extension, struct Vertex* listOfGraphs, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	struct Graph* result = NULL;
	struct Graph* g = extension;
	while (g != NULL) {
		// store second element, detach head
		struct Graph* tmp = g->next;
		g->next = NULL;

		struct ShallowGraph* string = canonicalStringOfTree(g, sgp);
		char alreadyFound = containsString(listOfGraphs, string);
		if (!alreadyFound) {
			addToSearchTree(listOfGraphs, string, gp, sgp);
			// add to result
			g->next = result;
			result = g;
		} else {
			dumpShallowGraph(sgp, string);
			dumpGraph(gp, g);
		}
		// move on
		g = tmp;
	}
	return result;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x31150
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq $0x0, 0x18(%rax)
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x9eb0
movq %rax, 0x8(%rsp)
movq 0x38(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x2c280
movb %al, 0x7(%rsp)
cmpb $0x0, 0x7(%rsp)
jne 0x31123
movq 0x38(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x30(%rsp), %rdx
movq 0x28(%rsp), %rcx
callq 0x2c520
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x18(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x31141
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x1ff70
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x1fb30
movq 0x10(%rsp), %rax
movq %rax, 0x18(%rsp)
jmp 0x3109b
movq 0x20(%rsp), %rax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/treeEnumerationRooted.c
// Function: extendRootedPatternAllWays
struct Graph* extendRootedPatternAllWays(struct Graph* g, struct ShallowGraph* candidateEdges, struct GraphPool* gp) {
	struct Graph* rho = NULL;
	struct VertexList* e;
	for (e=candidateEdges->edges; e!=NULL; e=e->next) {
		int v;
		for (v=0; v<g->n; ++v) {
			/* if the labels are compatible */
			if (strcmp(g->vertices[v]->label, e->startPoint->label) == 0) {
				struct Graph* h = refinementGraph(g, v, e, gp);
				h->next = rho;
				rho = h;
			}
		}
	}
	return rho;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x314ab
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x30(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x31496
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rsi
callq 0x1120
cmpl $0x0, %eax
jne 0x31487
movq 0x30(%rsp), %rdi
movl 0xc(%rsp), %esi
movq 0x10(%rsp), %rdx
movq 0x20(%rsp), %rcx
callq 0x309f0
movq %rax, (%rsp)
movq 0x18(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x18(%rax)
movq (%rsp), %rax
movq %rax, 0x18(%rsp)
jmp 0x31489
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x3141d
jmp 0x31498
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x31409
movq 0x18(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/treeKernels.c
// Function: cleanUpEdgeSort
void cleanUpEdgeSort(struct Vertex* v, struct ShallowGraphPool* sgp) {
	struct VertexList* e;
	struct VertexList* f;
	struct VertexList* first = getVertexList(sgp->listPool);
	struct ShallowGraph* fifo = getShallowGraph(sgp);

	/* create artificial edge to start bfs */
	first->endPoint = v;
	first->startPoint = v;
	appendEdge(fifo, first);

	/* bfs */
	while((e = popEdge(fifo))) {


			/* store distance */
			e->endPoint->visited = 0;

			/* put children in fifo queue */
			for (f=e->endPoint->neighborhood; f; f = f->next) {
				if (f->endPoint->visited) {
					appendEdge(fifo, shallowCopyEdge(f, sgp->listPool));
				}
			}

			dumpVertexList(sgp->listPool, e);

	}

	dumpShallowGraph(sgp, fifo);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x1f310
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
callq 0x1fe70
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x30(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xbf70
movq 0x8(%rsp), %rdi
callq 0xbef0
movq %rax, 0x20(%rsp)
cmpq $0x0, %rax
je 0x3184f
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rax
movl $0x0, 0x1c(%rax)
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x31837
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rax
cmpl $0x0, 0x1c(%rax)
je 0x31825
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0xa310
movq (%rsp), %rdi
movq %rax, %rsi
callq 0xbf70
jmp 0x31827
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
jmp 0x317e6
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x20(%rsp), %rsi
callq 0x1f410
jmp 0x317ab
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x1ff70
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)