LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/lwm_initAndCollect.c
// Function: hardCopyGraphLabels
static void hardCopyGraphLabels(struct Graph* g) {
	for (int vi=0; vi<g->n; ++vi) {
		struct Vertex* v = g->vertices[vi];
		if (v->isStringMaster == 0) {
			v->label = copyString(v->label);
			v->isStringMaster = 1;
		}
		for (struct VertexList* e=v->neighborhood; e!=NULL; e=e->next) {
			if (e->isStringMaster == 0) {
				e->label = copyString(e->label);
				e->isStringMaster = 1;
			}
		}
	}
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x1a3f1
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x1c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpl $0x0, 0x24(%rax)
jne 0x1a388
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x20090
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movl $0x1, 0x24(%rax)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x1a3df
movq 0x8(%rsp), %rax
cmpl $0x0, 0x28(%rax)
jne 0x1a3cd
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x20090
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movl $0x1, 0x28(%rax)
jmp 0x1a3cf
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x1a396
jmp 0x1a3e1
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x1a331
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/lwm_initAndCollect.c
// Function: getDBfromCanonicalStrings
int getDBfromCanonicalStrings(struct Graph*** db, FILE* stream, size_t bufferSize, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	int dbSize = 0;
	int i = 0;
	int graphId = -1;
	int graphCount = -1;
	char* buffer = malloc(bufferSize * sizeof(char));

	while (fscanf(stream, "%i\t%i\t", &graphCount, &graphId) == 2) {
		struct ShallowGraph* g = parseCString(stream, buffer, sgp);
		/* make space for storing graphs in array */
		if (dbSize <= i) {
			dbSize = dbSize == 0 ? 128 : dbSize * 2;
			*db = realloc(*db, dbSize * sizeof (struct Graph*));
		}
		/* store graph */
		(*db)[i] = treeCanonicalString2Graph(g, gp);
		(*db)[i]->number = graphId;
		(*db)[i]->activity = graphCount;
		hardCopyGraphLabels((*db)[i]);
		dumpShallowGraph(sgp, g);
		++i;
	}
	free(buffer);
	return i;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movl $0x0, 0x2c(%rsp)
movl $0x0, 0x28(%rsp)
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
movl $0xffffffff, 0x20(%rsp) # imm = 0xFFFFFFFF
movq 0x40(%rsp), %rdi
shlq $0x0, %rdi
callq 0x1170
movq %rax, 0x18(%rsp)
movq 0x48(%rsp), %rdi
leaq 0x1b4f8(%rip), %rsi     # 0x35954
leaq 0x20(%rsp), %rdx
leaq 0x24(%rsp), %rcx
movb $0x0, %al
callq 0x1050
cmpl $0x2, %eax
jne 0x1a566
movq 0x48(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x30(%rsp), %rdx
callq 0x9300
movq %rax, 0x10(%rsp)
movl 0x2c(%rsp), %eax
cmpl 0x28(%rsp), %eax
jg 0x1a4de
cmpl $0x0, 0x2c(%rsp)
jne 0x1a4ab
movl $0x80, %eax
movl %eax, 0xc(%rsp)
jmp 0x1a4b5
movl 0x2c(%rsp), %eax
shll %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x2c(%rsp)
movq 0x50(%rsp), %rax
movq (%rax), %rdi
movslq 0x2c(%rsp), %rsi
shlq $0x3, %rsi
callq 0x11a0
movq %rax, %rcx
movq 0x50(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0xa0f0
movq %rax, %rdx
movq 0x50(%rsp), %rax
movq (%rax), %rax
movslq 0x28(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl 0x24(%rsp), %ecx
movq 0x50(%rsp), %rax
movq (%rax), %rax
movslq 0x28(%rsp), %rdx
movq (%rax,%rdx,8), %rax
movl %ecx, 0x8(%rax)
movl 0x20(%rsp), %ecx
movq 0x50(%rsp), %rax
movq (%rax), %rax
movslq 0x28(%rsp), %rdx
movq (%rax,%rdx,8), %rax
movl %ecx, 0xc(%rax)
movq 0x50(%rsp), %rax
movq (%rax), %rax
movslq 0x28(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1a320
movq 0x30(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x1ff70
movl 0x28(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x28(%rsp)
jmp 0x1a450
movq 0x18(%rsp), %rdi
callq 0x1030
movl 0x28(%rsp), %eax
addq $0x58, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/lwm_initAndCollect.c
// Function: getPostorders
static int** getPostorders(struct Graph** db, int nGraphs) {
	int** postorderDB = malloc(nGraphs * sizeof(int*));
	for (int g=0; g<nGraphs; ++g) {
		postorderDB[g] = getPostorder(db[g], 0);
	}
	return postorderDB;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movslq 0x1c(%rsp), %rdi
shlq $0x3, %rdi
callq 0x1170
movq %rax, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x1c(%rsp), %eax
jge 0x1ace5
movq 0x20(%rsp), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
xorl %esi, %esi
callq 0x2df00
movq %rax, %rdx
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x1aca8
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/lwm_initAndCollect.c
// Function: getFrequentVerticesAndEdges
static void getFrequentVerticesAndEdges(struct Graph** db, int nGraphs, size_t threshold, struct Vertex** frequentVertices, struct Vertex** frequentEdges, FILE* logStream, struct GraphPool* gp) {
	*frequentVertices = getVertex(gp->vertexPool);
	*frequentEdges = getVertex(gp->vertexPool);

	/* get frequent vertices */
	int tmpResultSetSize = getFrequentVertices(db, nGraphs, *frequentVertices, gp);
	filterSearchTree(*frequentVertices, threshold, *frequentVertices, gp);
	fprintf(logStream, "Number of frequent vertices: %i\n", (*frequentVertices)->d); fflush(logStream);

	/* get frequent edges: first edge id is given by number of frequent vertices */
	offsetSearchTreeIds(*frequentEdges, (*frequentVertices)->lowPoint);
	getFrequentEdges(db, nGraphs, tmpResultSetSize, *frequentEdges, gp);
	filterSearchTree(*frequentEdges, threshold, *frequentEdges, gp);
	fprintf(logStream, "Number of frequent edges: %i\n", (*frequentEdges)->d); fflush(logStream);

}

// Assembly:
subq $0x38, %rsp
movq 0x40(%rsp), %rax
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq %r9, 0x8(%rsp)
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x1f6a0
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x1f6a0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
movq 0x18(%rsp), %rax
movq (%rax), %rdx
movq 0x40(%rsp), %rcx
callq 0x1a580
movl %eax, 0x4(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rdi
movq 0x20(%rsp), %rax
movl %eax, %esi
movq 0x18(%rsp), %rax
movq (%rax), %rdx
movq 0x40(%rsp), %rcx
callq 0x2cb50
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rax
movq (%rax), %rax
movl 0x28(%rax), %edx
leaq 0x1abbc(%rip), %rsi     # 0x3595b
movb $0x0, %al
callq 0x1140
movq 0x8(%rsp), %rdi
callq 0x1180
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x18(%rsp), %rax
movq (%rax), %rax
movl 0x20(%rax), %esi
callq 0x2c9e0
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
movl 0x4(%rsp), %edx
movq 0x10(%rsp), %rax
movq (%rax), %rcx
movq 0x40(%rsp), %r8
callq 0x1c5a0
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x20(%rsp), %rax
movl %eax, %esi
movq 0x10(%rsp), %rax
movq (%rax), %rdx
movq 0x40(%rsp), %rcx
callq 0x2cb50
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rax
movl 0x28(%rax), %edx
leaq 0x1ab5d(%rip), %rsi     # 0x3597c
movb $0x0, %al
callq 0x1140
movq 0x8(%rsp), %rdi
callq 0x1180
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/lwm_initAndCollect.c
// Function: createSingletonPatternSupportSetsForForestDB
static struct SupportSet* createSingletonPatternSupportSetsForForestDB(struct Graph** db, int** postorders, int nGraphs, struct Vertex* frequentVertices, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	(void)sgp; // unused
	// init levelwise search data structures for patterns with one vertex

	// data structures for iterative levelwise search
	struct SupportSet* vertexSupportSets = NULL;
	struct SupportSet* vertexSupportSetsTail = NULL;

	int id = 1;
	for (struct VertexList* e=frequentVertices->neighborhood; e!=NULL; e=e->next) {

		struct Graph* candidate = createGraph(1, gp);
		candidate->vertices[0]->label = e->label;
		e->endPoint->lowPoint = id;

		struct SupportSet* vertexSupport = getSupportSetOfVertex(db, postorders, nGraphs, candidate, id);

		if (vertexSupportSetsTail != NULL) {
			vertexSupportSetsTail->next = vertexSupport;
			vertexSupportSetsTail = vertexSupport;
		} else {
			vertexSupportSets = vertexSupport;
			vertexSupportSetsTail = vertexSupport;
		}
		++id;
	}
	return vertexSupportSets;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movl %edx, 0x54(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x38(%rsp)
movq $0x0, 0x30(%rsp)
movq $0x0, 0x28(%rsp)
movl $0x1, 0x24(%rsp)
movq 0x48(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x1af47
movq 0x40(%rsp), %rsi
movl $0x1, %edi
callq 0xb850
movq %rax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rcx
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq %rcx, (%rax)
movl 0x24(%rsp), %ecx
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rax
movl %ecx, 0x20(%rax)
movq 0x60(%rsp), %rdi
movq 0x58(%rsp), %rsi
movslq 0x54(%rsp), %rdx
movq 0x10(%rsp), %rcx
movl 0x24(%rsp), %r8d
callq 0x1c990
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x1af15
movq 0x8(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x28(%rsp)
jmp 0x1af29
movq 0x8(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x8(%rsp), %rax
movq %rax, 0x28(%rsp)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
jmp 0x1ae89
movq 0x30(%rsp), %rax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/lwm_initAndCollect.c
// Function: createSingletonPatternSupportSetsForLocalEasyDB
static struct SupportSet* createSingletonPatternSupportSetsForLocalEasyDB(struct SpanningtreeTree* sptTrees, int nGraphs, struct Vertex* frequentVertices, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	(void)sgp; // unused
	// init levelwise search data structures for patterns with one vertex

	// data structures for iterative levelwise search
	struct SupportSet* vertexSupportSets = NULL;
	struct SupportSet* vertexSupportSetsTail = NULL;

	int id = 1;
	for (struct VertexList* e=frequentVertices->neighborhood; e!=NULL; e=e->next) {

		struct Graph* candidate = createGraph(1, gp);
		candidate->vertices[0]->label = e->label;
		e->endPoint->lowPoint = id;

		struct SupportSet* vertexSupport = initLocalEasyForVertices(sptTrees, nGraphs, candidate, id);

		if (vertexSupportSetsTail != NULL) {
			vertexSupportSetsTail->next = vertexSupport;
			vertexSupportSetsTail = vertexSupport;
		} else {
			vertexSupportSets = vertexSupport;
			vertexSupportSetsTail = vertexSupport;
		}
		++id;
	}
	return vertexSupportSets;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq $0x0, 0x28(%rsp)
movq $0x0, 0x20(%rsp)
movl $0x1, 0x1c(%rsp)
movq 0x40(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x1bc37
movq 0x38(%rsp), %rsi
movl $0x1, %edi
callq 0xb850
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rcx
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq %rcx, (%rax)
movl 0x1c(%rsp), %ecx
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movl %ecx, 0x20(%rax)
movq 0x50(%rsp), %rdi
movslq 0x4c(%rsp), %rsi
movq 0x8(%rsp), %rdx
movl 0x1c(%rsp), %ecx
callq 0x1caf0
movq %rax, (%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x1bc07
movq (%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x10(%rax)
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x1bc19
movq (%rsp), %rax
movq %rax, 0x28(%rsp)
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x1bb84
movq 0x28(%rsp), %rax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/lwm_initAndCollect.c
// Function: garbageCollectFrequentTreeMiningForForestDB
void garbageCollectFrequentTreeMiningForForestDB(void** y, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	struct IterativeBfsForForestsDataStructures* dataStructures = (struct IterativeBfsForForestsDataStructures*)y;

	dumpSearchTree(gp, dataStructures->initialFrequentPatterns);
	dumpShallowGraphCycle(sgp, dataStructures->extensionEdges);
	dumpGraph(gp, dataStructures->extensionEdgesVertexStore);

	for (int i=0; i<dataStructures->nGraphs; ++i) {
		dumpGraph(gp, dataStructures->db[i]);
		free(dataStructures->postorders[i]);
	}

	free(dataStructures->db);
	free(dataStructures->postorders);
	free(dataStructures);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0x2d3c0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rsi
callq 0x20000
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rsi
callq 0x1fb30
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl 0x28(%rcx), %eax
jge 0x1c00b
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rax
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x1fb30
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1030
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x1bfbe
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x1030
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x1030
movq 0x8(%rsp), %rdi
callq 0x1030
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/lwm_initAndCollect.c
// Function: garbageCollectLocalEasyForGraphDB
void garbageCollectLocalEasyForGraphDB(void** y, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	struct IterativeBfsForLocalEasyDataStructures* dataStructures = (struct IterativeBfsForLocalEasyDataStructures*)y;

	dumpSearchTree(gp, dataStructures->initialFrequentPatterns);
	dumpShallowGraphCycle(sgp, dataStructures->extensionEdges);
	dumpGraph(gp, dataStructures->extensionEdgesVertexStore);

	for (int i=0; i<dataStructures->nGraphs; ++i) {
		dumpGraph(gp, dataStructures->sptTrees[i].g);
		dumpSpanningtreeTree(dataStructures->sptTrees[i], gp);
	}

	free(dataStructures->sptTrees);
	free(dataStructures);
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0x48(%rsp)
movq 0x58(%rsp), %rdi
movq 0x48(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0x2d3c0
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0x20000
movq 0x58(%rsp), %rdi
movq 0x48(%rsp), %rax
movq 0x18(%rax), %rsi
callq 0x1fb30
movl $0x0, 0x44(%rsp)
movl 0x44(%rsp), %eax
movq 0x48(%rsp), %rcx
cmpl 0x20(%rcx), %eax
jge 0x1c119
movq 0x58(%rsp), %rdi
movq 0x48(%rsp), %rax
movq (%rax), %rax
movslq 0x44(%rsp), %rcx
imulq $0x38, %rcx, %rcx
addq %rcx, %rax
movq (%rax), %rsi
callq 0x1fb30
movq 0x48(%rsp), %rax
movq (%rax), %rcx
movslq 0x44(%rsp), %rax
imulq $0x38, %rax, %rax
addq %rax, %rcx
movq 0x58(%rsp), %rdi
movq 0x30(%rcx), %rdx
movq %rsp, %rax
movq %rdx, 0x30(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups 0x20(%rcx), %xmm2
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x175f0
movl 0x44(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x44(%rsp)
jmp 0x1c09e
movq 0x48(%rsp), %rax
movq (%rax), %rdi
callq 0x1030
movq 0x48(%rsp), %rdi
callq 0x1030
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/lwm_initAndCollect.c
// Function: getSupportSetsOfVerticesForPatternEnumeration
struct SupportSet* getSupportSetsOfVerticesForPatternEnumeration(struct Graph** db, int nGraphs, struct Vertex* frequentVertices, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	(void)sgp; // unused
	// init levelwise search data structures for patterns with one vertex

	// data structures for iterative levelwise search
	struct SupportSet* vertexSupportSets = NULL;
	struct SupportSet* vertexSupportSetsTail = NULL;

	int id = 1;
	for (struct VertexList* e=frequentVertices->neighborhood; e!=NULL; e=e->next) {

		struct Graph* candidate = createGraph(1, gp);
		candidate->vertices[0]->label = e->label;
		e->endPoint->lowPoint = id;

		struct SupportSet* vertexSupport = initPatternEnumerationForVertices(db, nGraphs, candidate, id);

		if (vertexSupportSetsTail != NULL) {
			vertexSupportSetsTail->next = vertexSupport;
			vertexSupportSetsTail = vertexSupport;
		} else {
			vertexSupportSets = vertexSupport;
			vertexSupportSetsTail = vertexSupport;
		}
		++id;
	}
	return vertexSupportSets;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq %r8, 0x30(%rsp)
movq $0x0, 0x28(%rsp)
movq $0x0, 0x20(%rsp)
movl $0x1, 0x1c(%rsp)
movq 0x40(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x1c237
movq 0x38(%rsp), %rsi
movl $0x1, %edi
callq 0xb850
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rcx
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq %rcx, (%rax)
movl 0x1c(%rsp), %ecx
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movl %ecx, 0x20(%rax)
movq 0x50(%rsp), %rdi
movslq 0x4c(%rsp), %rsi
movq 0x8(%rsp), %rdx
movl 0x1c(%rsp), %ecx
callq 0x1c250
movq %rax, (%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x1c207
movq (%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x10(%rax)
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x1c219
movq (%rsp), %rax
movq %rax, 0x28(%rsp)
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x1c184
movq 0x28(%rsp), %rax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/lwm_initAndCollect.c
// Function: initPatternEnumerationForVertices
static struct SupportSet* initPatternEnumerationForVertices(struct Graph** spanningTreesDB, size_t nGraphs, struct Graph* h, int patternId) {
	struct SupportSet* actualSupport = getSupportSet();
	h->number = patternId;
	for (size_t i=0; i<nGraphs; ++i) {
		struct SubtreeIsoDataStore data = {0};
		data.g = spanningTreesDB[i];
		data.h = h;
		data.postorder = NULL;
		data.foundIso = 1;
		appendSupportSetData(actualSupport, data);
	}
	return actualSupport;
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movl %ecx, 0x6c(%rsp)
movb $0x0, %al
callq 0x2fd20
movq %rax, 0x60(%rsp)
movl 0x6c(%rsp), %ecx
movq 0x70(%rsp), %rax
movl %ecx, 0x8(%rax)
movq $0x0, 0x58(%rsp)
movq 0x58(%rsp), %rax
cmpq 0x78(%rsp), %rax
jae 0x1c316
leaq 0x30(%rsp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x10b0
movq 0x80(%rsp), %rax
movq 0x58(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x38(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x40(%rsp)
movq $0x0, 0x30(%rsp)
movl $0x1, 0x50(%rsp)
movq 0x60(%rsp), %rdi
movq 0x50(%rsp), %rcx
movq %rsp, %rax
movq %rcx, 0x20(%rax)
movups 0x30(%rsp), %xmm0
movups 0x40(%rsp), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x2fa10
movq 0x58(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x58(%rsp)
jmp 0x1c28e
movq 0x60(%rsp), %rax
addq $0x88, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/lwm_initAndCollect.c
// Function: garbageCollectPatternEnumeration
void garbageCollectPatternEnumeration(void** y, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	struct IterativeBfsForForestsDataStructures* dataStructures = (struct IterativeBfsForForestsDataStructures*)y;

	dumpSearchTree(gp, dataStructures->initialFrequentPatterns);
	dumpShallowGraphCycle(sgp, dataStructures->extensionEdges);
	dumpGraph(gp, dataStructures->extensionEdgesVertexStore);

	for (int i=0; i<dataStructures->nGraphs; ++i) {
		dumpGraph(gp, dataStructures->db[i]);
	}

	free(dataStructures->db);
	free(dataStructures);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0x2d3c0
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rsi
callq 0x20000
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rsi
callq 0x1fb30
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl 0x28(%rcx), %eax
jge 0x1c584
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rax
movq (%rax), %rax
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x1fb30
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x1c54e
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x1030
movq 0x8(%rsp), %rdi
callq 0x1030
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/lwm_initAndCollect.c
// Function: getSupportSetOfVertex
static struct SupportSet* getSupportSetOfVertex(struct Graph** db, int** postoderDB, size_t nGraphs, struct Graph* h, int patternId) {
	struct SupportSet* actualSupport = getSupportSet();
	h->number = patternId;
	for (size_t i=0; i<nGraphs; ++i) {
		struct SubtreeIsoDataStore base = {0};
		base.g = db[i];
		base.postorder = postoderDB[i];
		struct SubtreeIsoDataStore data = initIterativeSubtreeCheckForSingleton(base, h);
		if (data.foundIso) {
			appendSupportSetData(actualSupport, data);
		} else {
			dumpNewCube(data.S, data.g->n);
		}
	}
	return actualSupport;
}

// Assembly:
subq $0xb8, %rsp
movq %rdi, 0xb0(%rsp)
movq %rsi, 0xa8(%rsp)
movq %rdx, 0xa0(%rsp)
movq %rcx, 0x98(%rsp)
movl %r8d, 0x94(%rsp)
movb $0x0, %al
callq 0x2fd20
movq %rax, 0x88(%rsp)
movl 0x94(%rsp), %ecx
movq 0x98(%rsp), %rax
movl %ecx, 0x8(%rax)
movq $0x0, 0x80(%rsp)
movq 0x80(%rsp), %rax
cmpq 0xa0(%rsp), %rax
jae 0x1cad3
leaq 0x58(%rsp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x10b0
movq 0xb0(%rsp), %rax
movq 0x80(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x60(%rsp)
movq 0xa8(%rsp), %rax
movq 0x80(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x58(%rsp)
movq 0x98(%rsp), %rsi
movq 0x78(%rsp), %rcx
movq %rsp, %rax
movq %rcx, 0x20(%rax)
movups 0x58(%rsp), %xmm0
movups 0x68(%rsp), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
leaq 0x30(%rsp), %rdi
callq 0xf630
cmpl $0x0, 0x50(%rsp)
je 0x1caa7
movq 0x88(%rsp), %rdi
movq 0x50(%rsp), %rcx
movq %rsp, %rax
movq %rcx, 0x20(%rax)
movups 0x30(%rsp), %xmm0
movups 0x40(%rsp), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x2fa10
jmp 0x1cab8
movq 0x48(%rsp), %rdi
movq 0x38(%rsp), %rax
movl (%rax), %esi
callq 0x22fa0
jmp 0x1caba
movq 0x80(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x80(%rsp)
jmp 0x1c9ec
movq 0x88(%rsp), %rax
addq $0xb8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/lwm_initAndCollect.c
// Function: initLocalEasyForVertices
static struct SupportSet* initLocalEasyForVertices(struct SpanningtreeTree* spanningTreesDB, size_t nGraphs, struct Graph* h, int patternId) {
	struct SupportSet* actualSupport = getSupportSet();
	h->number = patternId;
	for (size_t i=0; i<nGraphs; ++i) {
		struct SubtreeIsoDataStore data = {0};
		data.g = spanningTreesDB[i].g;
		data.h = h;
		data.postorder = (int*)&(spanningTreesDB[i]); // we store a spanningtreetree pointer instead of a int
		data.foundIso = singletonSubgraphCheck(data.g, data.h);
		if (data.foundIso) {
			appendSupportSetData(actualSupport, data);
		}
	}
	return actualSupport;
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movl %ecx, 0x6c(%rsp)
movb $0x0, %al
callq 0x2fd20
movq %rax, 0x60(%rsp)
movl 0x6c(%rsp), %ecx
movq 0x70(%rsp), %rax
movl %ecx, 0x8(%rax)
movq $0x0, 0x58(%rsp)
movq 0x58(%rsp), %rax
cmpq 0x78(%rsp), %rax
jae 0x1cbe1
leaq 0x30(%rsp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x10b0
movq 0x80(%rsp), %rax
imulq $0x38, 0x58(%rsp), %rcx
addq %rcx, %rax
movq (%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x40(%rsp)
movq 0x80(%rsp), %rax
imulq $0x38, 0x58(%rsp), %rcx
addq %rcx, %rax
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x1cbf0
movsbl %al, %eax
movl %eax, 0x50(%rsp)
cmpl $0x0, 0x50(%rsp)
je 0x1cbcc
movq 0x60(%rsp), %rdi
movq 0x50(%rsp), %rcx
movq %rsp, %rax
movq %rcx, 0x20(%rax)
movups 0x30(%rsp), %xmm0
movups 0x40(%rsp), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x2fa10
jmp 0x1cbce
movq 0x58(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x58(%rsp)
jmp 0x1cb2e
movq 0x60(%rsp), %rax
addq $0x88, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/lwm_initAndCollect.c
// Function: singletonSubgraphCheck
static char singletonSubgraphCheck(struct Graph* g, struct Graph* h) {
	char* vertexLabel = h->vertices[0]->label;
	for (int v=0; v<g->n; ++v) {
		if (labelCmp(g->vertices[v]->label, vertexLabel) == 0) {
			return 1;
		}
	}
	return 0;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
movq 0x18(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x1cc61
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0x2dcf0
cmpl $0x0, %eax
jne 0x1cc52
movb $0x1, 0x27(%rsp)
jmp 0x1cc66
jmp 0x1cc54
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x1cc1a
movb $0x0, 0x27(%rsp)
movb 0x27(%rsp), %al
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/lwm_miningAndExtension.c
// Function: getCandidateSupportSuperSet
struct SupportSet* getCandidateSupportSuperSet(struct IntSet* parentIds, struct SupportSet* previousLevelSupportLists, int parentIdToKeep) {
	assert(parentIds != NULL);
	assert(previousLevelSupportLists != NULL);
	assert(containsInt(parentIds, parentIdToKeep));

	// obtain support sets of parents
	struct SupportSet* parentSupportSets = getSupportSetsOfPatterns(previousLevelSupportLists, parentIds);

	// move desired parent support set to head of list to keep the correct subtreeIsoDataStores
	parentSupportSets = supportSetChangeHead(parentSupportSets, parentIdToKeep);

	// compute a candidate support set that is the intersection of the support sets of the apriori parents of the extension
	struct SupportSet* candidateSupportSuperSet = intersectSupportSets(parentSupportSets);

	// garbage collection
	while (parentSupportSets) {
		struct SupportSet* tmp = parentSupportSets->next;
		free(parentSupportSets);
		parentSupportSets = tmp;
	}

	return candidateSupportSuperSet;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movl %edx, 0x24(%rsp)
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x30160
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0x302f0
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x30020
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x1cce4
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rdi
callq 0x1030
movq 0x8(%rsp), %rax
movq %rax, 0x18(%rsp)
jmp 0x1ccb8
movq 0x10(%rsp), %rax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/lwmr_embeddingOperators.c
// Function: rootedSubtreeComputationOperator
struct SubtreeIsoDataStore rootedSubtreeComputationOperator(struct SubtreeIsoDataStore data, struct Graph* h, double importance, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	(void)sgp; // unused
	(void)importance; // unused

	struct Vertex* rootEmbedding = NULL;
	struct SubtreeIsoDataStore result = noniterativeRootedSubtreeCheck(data, h, &rootEmbedding, gp);

//	if (result.foundIso) {
//		// nasty hack to output information on embeddings found (for all patterns, not only frequent ones) to stdout
//		fprintf(stdout, "emb %i %i %i\n", h->number, data.g->number, rootEmbedding->number);
//	}

	return result;
}

// Assembly:
subq $0x58, %rsp
movq %rdx, %rax
movq %rdi, %rdx
movq %rdx, 0x28(%rsp)
leaq 0x60(%rsp), %rdx
movq %rsi, 0x50(%rsp)
movsd %xmm0, 0x48(%rsp)
movq %rax, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq $0x0, 0x30(%rsp)
movq 0x50(%rsp), %rsi
movq 0x40(%rsp), %rcx
movq 0x20(%rdx), %r8
movq %rsp, %rax
movq %r8, 0x20(%rax)
movups (%rdx), %xmm0
movups 0x10(%rdx), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
leaq 0x30(%rsp), %rdx
callq 0xffb0
movq 0x28(%rsp), %rax
addq $0x58, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/lwmr_initAndCollect.c
// Function: getFrequentVerticesAndDirectedEdges
static void getFrequentVerticesAndDirectedEdges(struct Graph** db, int nGraphs, size_t threshold, struct Vertex** frequentVertices, struct Vertex** frequentEdges, FILE* logStream, struct GraphPool* gp) {
	*frequentVertices = getVertex(gp->vertexPool);
	*frequentEdges = getVertex(gp->vertexPool);

	/* get frequent vertices */
	int tmpResultSetSize = getFrequentVertices(db, nGraphs, *frequentVertices, gp);
	filterSearchTree(*frequentVertices, threshold, *frequentVertices, gp);
	fprintf(logStream, "Number of frequent vertices: %i\n", (*frequentVertices)->d); fflush(logStream);

	/* get frequent edges: first edge id is given by number of frequent vertices */
	offsetSearchTreeIds(*frequentEdges, (*frequentVertices)->lowPoint);
	getFrequentDirectedEdges(db, nGraphs, tmpResultSetSize, *frequentEdges, gp);
	filterSearchTree(*frequentEdges, threshold, *frequentEdges, gp);
	fprintf(logStream, "Number of frequent edges: %i\n", (*frequentEdges)->d); fflush(logStream);

}

// Assembly:
subq $0x38, %rsp
movq 0x40(%rsp), %rax
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq %r9, 0x8(%rsp)
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x1f6a0
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x1f6a0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
movq 0x18(%rsp), %rax
movq (%rax), %rdx
movq 0x40(%rsp), %rcx
callq 0x1a580
movl %eax, 0x4(%rsp)
movq 0x18(%rsp), %rax
movq (%rax), %rdi
movq 0x20(%rsp), %rax
movl %eax, %esi
movq 0x18(%rsp), %rax
movq (%rax), %rdx
movq 0x40(%rsp), %rcx
callq 0x2cb50
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rax
movq (%rax), %rax
movl 0x28(%rax), %edx
leaq 0x17e6c(%rip), %rsi     # 0x3595b
movb $0x0, %al
callq 0x1140
movq 0x8(%rsp), %rdi
callq 0x1180
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x18(%rsp), %rax
movq (%rax), %rax
movl 0x20(%rax), %esi
callq 0x2c9e0
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
movl 0x4(%rsp), %edx
movq 0x10(%rsp), %rax
movq (%rax), %rcx
movq 0x40(%rsp), %r8
callq 0x1ded0
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x20(%rsp), %rax
movl %eax, %esi
movq 0x10(%rsp), %rax
movq (%rax), %rdx
movq 0x40(%rsp), %rcx
callq 0x2cb50
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rax
movl 0x28(%rax), %edx
leaq 0x17e0d(%rip), %rsi     # 0x3597c
movb $0x0, %al
callq 0x1140
movq 0x8(%rsp), %rdi
callq 0x1180
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/memoryManagement.c
// Function: createListPool
struct ListPool* createListPool(unsigned int initNumberOfElements){
	struct ListPool* newPool;

	if (MEM_DEBUG) {
		// this allows the dump methods to free everything that is dumped
		initNumberOfElements = 1;
	}

	if ((newPool = malloc(sizeof(struct ListPool)))) {
		if ((newPool->unused = malloc(initNumberOfElements * sizeof(struct VertexList)))) {
			unsigned int i;
			/* we have allocated an array, but need a list, thus set ponters accordingly */
			for (i=0; i<initNumberOfElements-1; ++i) {
				(newPool->unused[i]).next = &(newPool->unused[i+1]);
			}
			(newPool->unused[initNumberOfElements-1]).next = NULL;
			newPool->poolPointer = newPool->unused;
			newPool->initNumberOfElements = initNumberOfElements;
		} else {
			printf("Error while initializing object pool for list elements\n");
			return NULL;
		}
	} else {
		printf("Error while initializing object pool for list elements\n");
		return NULL;
	}
	return newPool;
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x1c(%rsp)
movl $0x20, %edi
callq 0x1170
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x1f24d
movl 0x1c(%rsp), %eax
imulq $0x30, %rax, %rdi
callq 0x1170
movq 0x10(%rsp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
je 0x1f232
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl 0x1c(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jae 0x1f1f3
movq 0x10(%rsp), %rax
movq (%rax), %rcx
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, %eax
imulq $0x30, %rax, %rax
addq %rax, %rcx
movq 0x10(%rsp), %rax
movq (%rax), %rax
movl 0xc(%rsp), %edx
imulq $0x30, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x8(%rax)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x1f1a8
movq 0x10(%rsp), %rax
movq (%rax), %rax
movl 0x1c(%rsp), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq $0x0, 0x8(%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
movl 0x1c(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x10(%rax)
jmp 0x1f24b
leaq 0x168cf(%rip), %rdi     # 0x35b08
movb $0x0, %al
callq 0x1090
movq $0x0, 0x20(%rsp)
jmp 0x1f270
jmp 0x1f266
leaq 0x168b4(%rip), %rdi     # 0x35b08
movb $0x0, %al
callq 0x1090
movq $0x0, 0x20(%rsp)
jmp 0x1f270
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/memoryManagement.c
// Function: freeListPool
void freeListPool(struct ListPool *p) {
	while (p->unused) {
		p->tmp = p->unused->next;
		if ((p->unused < p->poolPointer) || (p->unused > &(p->poolPointer[p->initNumberOfElements-1]))) {
			free(p->unused);
		}
		p->unused = p->tmp;
	}
	if (!MEM_DEBUG) {
		free(p->poolPointer);
	}
	free(p);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
cmpq $0x0, (%rax)
je 0x1f2f7
movq (%rsp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq (%rsp), %rax
movq (%rax), %rax
movq (%rsp), %rcx
cmpq 0x18(%rcx), %rax
jb 0x1f2da
movq (%rsp), %rax
movq (%rax), %rax
movq (%rsp), %rcx
movq 0x18(%rcx), %rcx
movq (%rsp), %rdx
movl 0x10(%rdx), %edx
subl $0x1, %edx
movl %edx, %edx
imulq $0x30, %rdx, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jbe 0x1f2e6
movq (%rsp), %rax
movq (%rax), %rdi
callq 0x1030
movq (%rsp), %rax
movq 0x8(%rax), %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
jmp 0x1f285
movq (%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x1030
movq (%rsp), %rdi
callq 0x1030
popq %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/memoryManagement.c
// Function: getVertexList
struct VertexList* getVertexList(struct ListPool* p){
	if (p->unused) {
		/* get first of the unused elements */
		p->tmp = p->unused;
		p->unused = p->tmp->next;
	} else {
		/* allocate memory for new struct */
		if (!(p->tmp = malloc(sizeof(struct VertexList)))) {
			/* malloc did not work */
			printf("Error allocating memory\n");
			return NULL;
		} 
	}
	
	/* The malloc worked or we had an element left. So we initialize the struct */
	wipeVertexList(p->tmp);

	return p->tmp;
		
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq $0x0, (%rax)
je 0x1f34c
movq 0x8(%rsp), %rax
movq (%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
jmp 0x1f380
movl $0x30, %edi
callq 0x1170
movq 0x8(%rsp), %rcx
movq %rax, 0x8(%rcx)
cmpq $0x0, %rax
jne 0x1f37e
leaq 0x167d4(%rip), %rdi     # 0x35b40
movb $0x0, %al
callq 0x1090
movq $0x0, 0x10(%rsp)
jmp 0x1f39c
jmp 0x1f380
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x1f3b0
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/memoryManagement.c
// Function: wipeVertexList
void wipeVertexList(struct VertexList* e) {
	e->startPoint = NULL;
	e->endPoint = NULL;
	e->label = NULL;

	e->next = NULL;

	e->used = 0;
	e->isStringMaster = 0;
	e->flag = 0;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rsp), %rax
movq $0x0, (%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rsp), %rax
movl $0x0, 0x20(%rax)
movq -0x8(%rsp), %rax
movl $0x0, 0x28(%rax)
movq -0x8(%rsp), %rax
movl $0x0, 0x24(%rax)
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/memoryManagement.c
// Function: dumpVertexList
void dumpVertexList(struct ListPool* p, struct VertexList* l) {
	/* free the label string, if l manages it */
	if (l->isStringMaster) {
		free(l->label);
	}

	if (MEM_DEBUG) {
		free(l);
	} else {
		/* add l to the unused list */
		l->next = p->unused;
		p->unused = l;
	}
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpl $0x0, 0x28(%rax)
je 0x1f436
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x1030
movq 0x10(%rsp), %rax
movq (%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/memoryManagement.c
// Function: dumpVertexListLinearly
void dumpVertexListLinearly(struct ListPool* p, struct VertexList* e) {
	struct VertexList* tmp;
	while (e) {
		tmp = e->next;
		dumpVertexList(p,e);
		e = tmp;
	}

}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x1f4dd
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x1f410
movq (%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x1f4ae
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/memoryManagement.c
// Function: createVertexPool
struct VertexPool* createVertexPool(unsigned int initNumberOfElements){
	struct VertexPool* newPool;

	if (MEM_DEBUG) {
		// this allows the dump methods to free everything that is dumped
		initNumberOfElements = 1;
	}

	if ((newPool = malloc(sizeof(struct VertexPool)))) {
		if ((newPool->unused = malloc(initNumberOfElements * sizeof(struct Vertex)))) {
			unsigned int i;
			/* we have allocated an array, but need a list, thus set ponters accordingly */
			for (i=0; i<initNumberOfElements-1; ++i) {
				(newPool->unused[i]).next = &(newPool->unused[i+1]);
			}
			(newPool->unused[initNumberOfElements-1]).next = NULL;
			newPool->poolPointer = newPool->unused;
			newPool->initNumberOfElements = initNumberOfElements;
		} else {
			printf("Error while initializing object pool for list elements\n");
			return NULL;
		}
	} else {
		printf("Error while initializing object pool for list elements\n");
		return NULL;
	}
	
	return newPool;
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x1c(%rsp)
movl $0x20, %edi
callq 0x1170
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x1f5dd
movl 0x1c(%rsp), %eax
imulq $0x30, %rax, %rdi
callq 0x1170
movq 0x10(%rsp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
je 0x1f5c2
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl 0x1c(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jae 0x1f583
movq 0x10(%rsp), %rax
movq (%rax), %rcx
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, %eax
imulq $0x30, %rax, %rax
addq %rax, %rcx
movq 0x10(%rsp), %rax
movq (%rax), %rax
movl 0xc(%rsp), %edx
imulq $0x30, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x10(%rax)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x1f538
movq 0x10(%rsp), %rax
movq (%rax), %rax
movl 0x1c(%rsp), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq $0x0, 0x10(%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
movl 0x1c(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x10(%rax)
jmp 0x1f5db
leaq 0x1653f(%rip), %rdi     # 0x35b08
movb $0x0, %al
callq 0x1090
movq $0x0, 0x20(%rsp)
jmp 0x1f600
jmp 0x1f5f6
leaq 0x16524(%rip), %rdi     # 0x35b08
movb $0x0, %al
callq 0x1090
movq $0x0, 0x20(%rsp)
jmp 0x1f600
movq 0x10(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/memoryManagement.c
// Function: freeVertexPool
void freeVertexPool(struct VertexPool *p) {
	while (p->unused) {
		p->tmp = p->unused->next;
		if ((p->unused < p->poolPointer) || (p->unused > &(p->poolPointer[p->initNumberOfElements-1]))) {
			free(p->unused);
		}
		p->unused = p->tmp;
	}
	if (!MEM_DEBUG) {
		free(p->poolPointer);
	}
	free(p);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
cmpq $0x0, (%rax)
je 0x1f687
movq (%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq (%rsp), %rax
movq (%rax), %rax
movq (%rsp), %rcx
cmpq 0x18(%rcx), %rax
jb 0x1f66a
movq (%rsp), %rax
movq (%rax), %rax
movq (%rsp), %rcx
movq 0x18(%rcx), %rcx
movq (%rsp), %rdx
movl 0x10(%rdx), %edx
subl $0x1, %edx
movl %edx, %edx
imulq $0x30, %rdx, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jbe 0x1f676
movq (%rsp), %rax
movq (%rax), %rdi
callq 0x1030
movq (%rsp), %rax
movq 0x8(%rax), %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
jmp 0x1f615
movq (%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x1030
movq (%rsp), %rdi
callq 0x1030
popq %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/memoryManagement.c
// Function: getVertex
struct Vertex* getVertex(struct VertexPool* p){
		if (p->unused) {
		/* get first of the unused elements */
		p->tmp = p->unused;
		p->unused = p->tmp->next;
	} else {
		/* allocate memory for new struct */
		if (!(p->tmp = malloc(sizeof(struct Vertex)))) {
			/* malloc did not work */
			printf("Error allocating memory\n");
			return NULL;
		} 
	}
	
	/* The malloc worked or we had an element left. So we initialize the struct */
	wipeVertex(p->tmp);
	
	return p->tmp;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq $0x0, (%rax)
je 0x1f6dc
movq 0x8(%rsp), %rax
movq (%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
jmp 0x1f710
movl $0x30, %edi
callq 0x1170
movq 0x8(%rsp), %rcx
movq %rax, 0x8(%rcx)
cmpq $0x0, %rax
jne 0x1f70e
leaq 0x16444(%rip), %rdi     # 0x35b40
movb $0x0, %al
callq 0x1090
movq $0x0, 0x10(%rsp)
jmp 0x1f72c
jmp 0x1f710
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x1f740
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/memoryManagement.c
// Function: wipeVertex
void wipeVertex(struct Vertex* v) {
	v->label = NULL;
	v->next = NULL;
	v->neighborhood = NULL;
	v->number = 0;
	v->visited = 0;
	v->isStringMaster = 0;
	v->lowPoint = 0;
	v->d = 0;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq $0x0, (%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rsp), %rax
movl $0x0, 0x18(%rax)
movq -0x8(%rsp), %rax
movl $0x0, 0x1c(%rax)
movq -0x8(%rsp), %rax
movl $0x0, 0x24(%rax)
movq -0x8(%rsp), %rax
movl $0x0, 0x20(%rax)
movq -0x8(%rsp), %rax
movl $0x0, 0x28(%rax)
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/memoryManagement.c
// Function: wipeVertexButKeepNumber
void wipeVertexButKeepNumber(struct Vertex* v) {
	v->label = NULL;
	v->next = NULL;
	v->neighborhood = NULL;
	v->visited = 0;
	v->isStringMaster = 0;
	v->lowPoint = 0;
	v->d = 0;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq $0x0, (%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rsp), %rax
movl $0x0, 0x1c(%rax)
movq -0x8(%rsp), %rax
movl $0x0, 0x24(%rax)
movq -0x8(%rsp), %rax
movl $0x0, 0x20(%rax)
movq -0x8(%rsp), %rax
movl $0x0, 0x28(%rax)
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/memoryManagement.c
// Function: dumpVertex
void dumpVertex(struct VertexPool* p, struct Vertex* v){
	
	if (v->isStringMaster) {
		free(v->label);
	}

	if (MEM_DEBUG) {
		free(v);
	} else {
		/* add v to the unused list */
		v->next = p->unused;
		p->unused = v;
	}
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpl $0x0, 0x24(%rax)
je 0x1f836
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x1030
movq 0x10(%rsp), %rax
movq (%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/memoryManagement.c
// Function: createGraphPool
struct GraphPool* createGraphPool(unsigned int initNumberOfElements, struct VertexPool* vp, struct ListPool* lp) {
	struct GraphPool* newPool;

	if (MEM_DEBUG) {
		// this allows the dump methods to free everything that is dumped
		initNumberOfElements = 1;
	}

	if ((newPool = malloc(sizeof(struct GraphPool)))) {
		/* set the listpool and vertexpool of the graphpool according to the input. good for dumping actions */
		newPool->vertexPool = vp;
		newPool->listPool = lp;

		
		if ((newPool->unused = malloc(initNumberOfElements * sizeof(struct Graph)))) {
			unsigned int i;
			/* we have allocated an array, but need a list, thus set ponters accordingly */
			for (i=0; i<initNumberOfElements-1; ++i) {
				(newPool->unused[i]).next = &(newPool->unused[i+1]);
			}
			(newPool->unused[initNumberOfElements-1]).next = NULL;
			newPool->poolPointer = newPool->unused;
			newPool->initNumberOfElements = initNumberOfElements;
		} else {
			printf("Error while initializing object pool for list elements\n");
			return NULL;
		}
	} else {
		printf("Error while initializing object pool for list elements\n");
		return NULL;
	}
	
	return newPool;
}

// Assembly:
subq $0x38, %rsp
movl %edi, 0x2c(%rsp)
movq %rsi, 0x20(%rsp)
movq %rdx, 0x18(%rsp)
movl $0x30, %edi
callq 0x1170
movq %rax, 0x10(%rsp)
cmpq $0x0, %rax
je 0x1f975
movq 0x20(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x18(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
movl 0x2c(%rsp), %eax
movl %eax, %edi
shlq $0x5, %rdi
callq 0x1170
movq 0x10(%rsp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
je 0x1f95a
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl 0x2c(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jae 0x1f91b
movq 0x10(%rsp), %rax
movq (%rax), %rcx
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, %eax
shlq $0x5, %rax
addq %rax, %rcx
movq 0x10(%rsp), %rax
movq (%rax), %rax
movl 0xc(%rsp), %edx
shlq $0x5, %rdx
addq %rdx, %rax
movq %rcx, 0x18(%rax)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x1f8d0
movq 0x10(%rsp), %rax
movq (%rax), %rax
movl 0x2c(%rsp), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
shlq $0x5, %rcx
addq %rcx, %rax
movq $0x0, 0x18(%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x28(%rax)
movl 0x2c(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, 0x20(%rax)
jmp 0x1f973
leaq 0x161a7(%rip), %rdi     # 0x35b08
movb $0x0, %al
callq 0x1090
movq $0x0, 0x30(%rsp)
jmp 0x1f998
jmp 0x1f98e
leaq 0x1618c(%rip), %rdi     # 0x35b08
movb $0x0, %al
callq 0x1090
movq $0x0, 0x30(%rsp)
jmp 0x1f998
movq 0x10(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)