LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/cs_Outerplanar.c
// Function: _compareDiagonals
int __compareDiagonals(const void* e1, const void* e2) {

	struct VertexList* e = *((struct VertexList**)e1);
	struct VertexList* f = *((struct VertexList**)e2);

	if (e->flag - f->flag == 0) {
		return e->used - f->used;
	} else {
		return e->flag - f->flag;
	}
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rsp)
movq -0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rsp)
movq -0x20(%rsp), %rax
movl 0x24(%rax), %eax
movq -0x28(%rsp), %rcx
subl 0x24(%rcx), %eax
cmpl $0x0, %eax
jne 0x6b3f
movq -0x20(%rsp), %rax
movl 0x20(%rax), %eax
movq -0x28(%rsp), %rcx
subl 0x20(%rcx), %eax
movl %eax, -0x4(%rsp)
jmp 0x6b53
movq -0x20(%rsp), %rax
movl 0x24(%rax), %eax
movq -0x28(%rsp), %rcx
subl 0x24(%rcx), %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/cs_Outerplanar.c
// Function: _appendDiagonal
void __appendDiagonal(struct ShallowGraph* diags, int start, int end, char* label, struct ListPool* p) {
	appendEdge(diags, getInitialisatorEdge(p));

	appendEdge(diags, getVertexList(p));
	diags->lastEdge->label = malloc(12*sizeof(char));
	diags->lastEdge->isStringMaster = 1;
	sprintf(diags->lastEdge->label, "%i", start);

	appendEdge(diags, getVertexList(p));
	diags->lastEdge->label = malloc(12*sizeof(char));
	diags->lastEdge->isStringMaster = 1;
	sprintf(diags->lastEdge->label, "%i", end);

	appendEdge(diags, getVertexList(p));
	diags->lastEdge->label = label;

	appendEdge(diags, getTerminatorEdge(p));
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movl %edx, 0x38(%rsp)
movq %rcx, 0x30(%rsp)
movq %r8, 0x28(%rsp)
movq 0x40(%rsp), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rdi
callq 0x9000
movq (%rsp), %rdi
movq %rax, %rsi
callq 0xbf70
movq 0x40(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
callq 0x1f310
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0xbf70
movl $0xc, %edi
callq 0x1170
movq %rax, %rcx
movq 0x40(%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq 0x40(%rsp), %rax
movq 0x8(%rax), %rax
movl $0x1, 0x28(%rax)
movq 0x40(%rsp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rdi
movl 0x3c(%rsp), %edx
leaq 0x2f309(%rip), %rsi     # 0x365f4
movb $0x0, %al
callq 0x11f0
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
callq 0x1f310
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0xbf70
movl $0xc, %edi
callq 0x1170
movq %rax, %rcx
movq 0x40(%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq 0x40(%rsp), %rax
movq 0x8(%rax), %rax
movl $0x1, 0x28(%rax)
movq 0x40(%rsp), %rax
movq 0x8(%rax), %rax
movq (%rax), %rdi
movl 0x38(%rsp), %edx
leaq 0x2f2a1(%rip), %rsi     # 0x365f4
movb $0x0, %al
callq 0x11f0
movq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rdi
callq 0x1f310
movq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0xbf70
movq 0x30(%rsp), %rcx
movq 0x40(%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, (%rax)
movq 0x40(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x28(%rsp), %rdi
callq 0x8fc0
movq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0xbf70
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/cs_Outerplanar.c
// Function: canonicalStringOfOuterplanarGraph
struct ShallowGraph* canonicalStringOfOuterplanarGraph(struct ShallowGraph* original, struct ShallowGraphPool* sgp, struct GraphPool* gp) {
	struct Graph* g = shallowGraphToGraph(original, gp);
	struct ShallowGraph* hamiltonianCycle = __getCycleAndDiagonals(g, sgp);
	if (hamiltonianCycle != NULL) {
		struct ShallowGraph* diagonals = hamiltonianCycle->next;	
		struct ShallowGraph* cString;
		hamiltonianCycle->next = NULL;
		cString = canonicalStringOfOuterplanarBlock(hamiltonianCycle, diagonals, sgp);
		dumpGraph(gp, g);
		return cString;
	} else {
		dumpGraph(gp, g);
		return NULL;
	}
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x38(%rsp)
movq %rsi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0xb1e0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x7bc0
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x8f72
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 0x10(%rsp), %rsi
movq 0x30(%rsp), %rdx
callq 0x79d0
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x1fb30
movq 0x8(%rsp), %rax
movq %rax, 0x40(%rsp)
jmp 0x8f8a
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x1fb30
movq $0x0, 0x40(%rsp)
movq 0x40(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/cs_Parsing.c
// Function: canonicalStringToChar
char* canonicalStringToChar(struct ShallowGraph* string) {
	char* out;
	struct VertexList* e;
	int size = 0;
	int i;

	/* count the space needed for the string (+1 for a whitespace separating two labels) */
	for (e=string->edges; e; e=e->next) {
		size += strlen(e->label) + 1;
	}
	out = malloc((size + 1) * sizeof(char));


	for (e=string->edges, i=0; e; e=e->next) {
		sprintf(&(out[i]), "%s ", e->label);
		i += strlen(e->label) + 1;
	}

	return out;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl $0x0, 0xc(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x9096
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x1080
movq %rax, %rcx
addq $0x1, %rcx
movslq 0xc(%rsp), %rax
addq %rcx, %rax
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x905e
movl 0xc(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x0, %rdi
callq 0x1170
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x911e
movq 0x18(%rsp), %rdi
movslq 0x8(%rsp), %rax
addq %rax, %rdi
movq 0x10(%rsp), %rax
movq (%rax), %rdx
leaq 0x2c163(%rip), %rsi     # 0x3524a
movb $0x0, %al
callq 0x11f0
movq 0x10(%rsp), %rax
movq (%rax), %rdi
callq 0x1080
movq %rax, %rcx
addq $0x1, %rcx
movslq 0x8(%rsp), %rax
addq %rcx, %rax
movl %eax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x90c3
movq 0x18(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/cs_Parsing.c
// Function: printCanonicalString
void printCanonicalString(struct ShallowGraph* s, FILE* stream) {
	struct VertexList *i;
	for (i=s->edges; i; i = i->next) {	
		char* j;
		for (j=i->label; *j != '\0'; ++j) {
			fputc(*j, stream);
		}
		fputc(' ', stream);
	}
	fputc('\n', stream);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x91ae
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movsbl (%rax), %eax
cmpl $0x0, %eax
je 0x918f
movq 0x8(%rsp), %rax
movsbl (%rax), %edi
movq 0x18(%rsp), %rsi
callq 0x10f0
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x9160
movq 0x18(%rsp), %rsi
movl $0x20, %edi
callq 0x10f0
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x914b
movq 0x18(%rsp), %rsi
movl $0xa, %edi
callq 0x10f0
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/cs_Parsing.c
// Function: _notDone
char __notDone(FILE* stream) {
	int c;
    for (c = fgetc(stream); c == ' '; c = fgetc(stream));
    ungetc(c, stream);
	return (c != '\0') && (c != '\n');
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x10c0
movl %eax, 0xc(%rsp)
cmpl $0x20, 0xc(%rsp)
jne 0x9240
jmp 0x9230
movq 0x10(%rsp), %rdi
callq 0x10c0
movl %eax, 0xc(%rsp)
jmp 0x9227
movl 0xc(%rsp), %edi
movq 0x10(%rsp), %rsi
callq 0x1190
xorl %eax, %eax
cmpl $0x0, 0xc(%rsp)
movb %al, 0xb(%rsp)
je 0x9267
cmpl $0xa, 0xc(%rsp)
setne %al
movb %al, 0xb(%rsp)
movb 0xb(%rsp), %al
andb $0x1, %al
movzbl %al, %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/cs_Parsing.c
// Function: parseCString
struct ShallowGraph* parseCString(FILE* stream, char* buffer, struct ShallowGraphPool* sgp) {
	struct ShallowGraph* string = getShallowGraph(sgp);
	struct VertexList* e;
	
	while (__notDone(stream)) {
		__readLabel(stream, buffer);
		e = getVertexList(sgp->listPool);
		if (strcmp(buffer, termString) == 0) {
			e->label = termString;
		} else {
			if (strcmp(buffer, initString) == 0) {
				e->label = initString;
			} else {
				int length = strlen(buffer) + 1;
				char* label = malloc(length * sizeof(char));
				strcpy(label, buffer);
				e->label = label;
				e->isStringMaster = 1;
			}
		}
		appendEdge(string, e);
	}
	return string;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x20(%rsp), %rdi
callq 0x1fe70
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
callq 0x9210
cmpb $0x0, %al
je 0x9404
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x9280
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x1f310
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
movq 0x34dd6(%rip), %rsi     # 0x3e138
callq 0x1120
cmpl $0x0, %eax
jne 0x937d
movq 0x34dc5(%rip), %rcx     # 0x3e138
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
jmp 0x93f0
movq 0x28(%rsp), %rdi
movq 0x34da7(%rip), %rsi     # 0x3e130
callq 0x1120
cmpl $0x0, %eax
jne 0x93a4
movq 0x34d96(%rip), %rcx     # 0x3e130
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
jmp 0x93ee
movq 0x28(%rsp), %rdi
callq 0x1080
addq $0x1, %rax
movl %eax, 0xc(%rsp)
movslq 0xc(%rsp), %rdi
shlq $0x0, %rdi
callq 0x1170
movq %rax, (%rsp)
movq (%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x1040
movq (%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movl $0x1, 0x28(%rax)
jmp 0x93f0
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xbf70
jmp 0x9322
movq 0x18(%rsp), %rax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/cs_Parsing.c
// Function: string2cstring
struct ShallowGraph* string2cstring(char* str, struct ShallowGraphPool* sgp) {
	FILE* f = str2stream(str);
	char x[20];
	struct ShallowGraph* cstr = parseCString(f, x, sgp);
	fclose(f);
	return cstr;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x40(%rsp), %rdi
callq 0x9460
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
leaq 0x10(%rsp), %rsi
movq 0x38(%rsp), %rdx
callq 0x9300
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rdi
callq 0x1070
movq 0x8(%rsp), %rax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/cs_Parsing.c
// Function: str2stream
static FILE* str2stream(char* str) {
	// extremely dangerous and extremely nasty
	FILE* f = fopen("/tmp/nasty", "w");
	fprintf(f, "%s", str);
	fclose(f);
	return fopen("/tmp/nasty", "r");
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
leaq 0x2bcda(%rip), %rdi     # 0x3514a
leaq 0x2d2a6(%rip), %rsi     # 0x3671d
callq 0x11b0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rdx
leaq 0x2bcc3(%rip), %rsi     # 0x35155
movb $0x0, %al
callq 0x1140
movq 0x8(%rsp), %rdi
callq 0x1070
leaq 0x2bca0(%rip), %rdi     # 0x3514a
leaq 0x2bca7(%rip), %rsi     # 0x35158
callq 0x11b0
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/cs_Tree.c
// Function: canonicalStringOfLevelTree
struct ShallowGraph* canonicalStringOfLevelTree(struct ShallowGraph* vertexList, int maxDepth, struct ShallowGraphPool* sgp) {

	struct VertexList* idx;
	struct ShallowGraph* canonicalString = NULL;

	/* compute the canonical string of the unique tree rooted at vertex i and save it at the correct position of the
	canonicalStrings array */
	for (idx=vertexList->edges; idx && (idx->endPoint->visited <= maxDepth); idx=idx->next) {

		/* compute the canonical string */
		struct ShallowGraph *cs = canonicalStringOfRootedLevelTree(idx->endPoint, NULL, maxDepth, sgp);

		/* keep the string if its the first one, computed for this component or lexicograhically smaller
			than the saved string */
		if (canonicalString) {
			if (compareCanonicalStrings(canonicalString, cs) > 0) {
				dumpShallowGraph(sgp, canonicalString);
				canonicalString = cs;
			} else {
				dumpShallowGraph(sgp, cs);
			}
		} else {
			canonicalString = cs;
		}

	}

	return canonicalString;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq %rdx, 0x20(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
xorl %eax, %eax
cmpq $0x0, 0x18(%rsp)
movb %al, 0x7(%rsp)
je 0x9b9d
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rax
movl 0x1c(%rax), %eax
cmpl 0x2c(%rsp), %eax
setle %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x9baa
jmp 0x9c31
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rdi
movl 0x2c(%rsp), %edx
movq 0x20(%rsp), %rcx
xorl %eax, %eax
movl %eax, %esi
callq 0x97f0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x9c12
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x6360
cmpl $0x0, %eax
jle 0x9c01
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x1ff70
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x9c10
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x1ff70
jmp 0x9c1c
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x9c1e
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
jmp 0x9b78
movq 0x10(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/cs_Tree.c
// Function: canonicalStringOfTree
struct ShallowGraph* canonicalStringOfTree(struct Graph* tree, struct ShallowGraphPool* sgp) {
	struct ShallowGraph* cString;
	int* center = treeCenter(tree);

	cString = canonicalStringOfRootedTree(tree->vertices[center[1]], tree->vertices[center[1]], sgp);
	
	if (center[0] == 3) {
		struct ShallowGraph* cString2 = canonicalStringOfRootedTree(tree->vertices[center[2]], tree->vertices[center[2]], sgp);
		if (compareCanonicalStrings(cString, cString2) < 0) {
			dumpShallowGraph(sgp, cString2);
		} else {
			dumpShallowGraph(sgp, cString);
			cString = cString2;
		}
	}
	free(center);
	return cString;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rdi
callq 0x30750
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rsp), %rcx
movslq 0x4(%rcx), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rsp), %rcx
movslq 0x4(%rcx), %rcx
movq (%rax,%rcx,8), %rsi
movq 0x18(%rsp), %rdx
callq 0x94c0
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rax
cmpl $0x3, (%rax)
jne 0x9f89
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rsp), %rcx
movslq 0x8(%rcx), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rsp), %rcx
movslq 0x8(%rcx), %rcx
movq (%rax,%rcx,8), %rsi
movq 0x18(%rsp), %rdx
callq 0x94c0
movq %rax, (%rsp)
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
callq 0x6360
cmpl $0x0, %eax
jge 0x9f6f
movq 0x18(%rsp), %rdi
movq (%rsp), %rsi
callq 0x1ff70
jmp 0x9f87
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x1ff70
movq (%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x9f89
movq 0x8(%rsp), %rdi
callq 0x1030
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/cs_Tree.c
// Function: _canonicalString2GraphRec
int __canonicalString2GraphRec(struct Graph* g, int current, int parent, struct ShallowGraph* suffix, struct VertexList* initEdge, struct VertexList* termEdge, struct GraphPool* gp) {

	/* for all children of parent */
	while (suffix->edges != NULL) {
		char* edgeLabel;

		if (strcmp(suffix->edges->label, termEdge->label) == 0) {
			suffix->edges = suffix->edges->next;
			return current;
		}
		
		/* first comes edge label */
		suffix->edges = suffix->edges->next;
		edgeLabel = suffix->edges->label;

		/* now comes the vertex label */
		suffix->edges = suffix->edges->next;
		g->vertices[current]->label = suffix->edges->label;

		addEdgeBetweenVertices(parent, current, edgeLabel, g, gp);

		/* recursive call */
		suffix->edges = suffix->edges->next;
		current = __canonicalString2GraphRec(g, current + 1, current, suffix, initEdge, termEdge, gp);
	}

	/* return position of next free vertex in g */
	return current;
}

// Assembly:
subq $0x48, %rsp
movq 0x50(%rsp), %rax
movq %rdi, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movl %edx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq %r8, 0x20(%rsp)
movq %r9, 0x18(%rsp)
movq 0x28(%rsp), %rax
cmpq $0x0, (%rax)
je 0xa0d0
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rdi
movq 0x18(%rsp), %rax
movq (%rax), %rsi
callq 0x1120
cmpl $0x0, %eax
jne 0xa012
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rcx
movq 0x28(%rsp), %rax
movq %rcx, (%rax)
movl 0x34(%rsp), %eax
movl %eax, 0x44(%rsp)
jmp 0xa0d8
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rcx
movq 0x28(%rsp), %rax
movq %rcx, (%rax)
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rcx
movq 0x28(%rsp), %rax
movq %rcx, (%rax)
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rcx
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x34(%rsp), %rdx
movq (%rax,%rdx,8), %rax
movq %rcx, (%rax)
movl 0x30(%rsp), %edi
movl 0x34(%rsp), %esi
movq 0x10(%rsp), %rdx
movq 0x38(%rsp), %rcx
movq 0x50(%rsp), %r8
callq 0xb670
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rcx
movq 0x28(%rsp), %rax
movq %rcx, (%rax)
movq 0x38(%rsp), %rdi
movl 0x34(%rsp), %esi
addl $0x1, %esi
movl 0x34(%rsp), %edx
movq 0x28(%rsp), %rcx
movq 0x20(%rsp), %r8
movq 0x18(%rsp), %r9
movq 0x50(%rsp), %rax
movq %rax, (%rsp)
callq 0x9fa0
movl %eax, 0x34(%rsp)
jmp 0x9fc5
movl 0x34(%rsp), %eax
movl %eax, 0x44(%rsp)
movl 0x44(%rsp), %eax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/cs_Tree.c
// Function: treeCanonicalString2Graph
struct Graph* treeCanonicalString2Graph(struct ShallowGraph* pattern, struct GraphPool* gp) {
	struct VertexList* initEdge = getInitialisatorEdge(gp->listPool);
	struct VertexList* termEdge = getTerminatorEdge(gp->listPool);
	struct VertexList* e;
	int n = 0;
	struct Graph* g;
	struct VertexList* head = pattern->edges;

	/* find number of vertices, create graph */
	for (e=pattern->edges; e!=NULL; e=e->next) {
		if (strcmp(e->label, initEdge->label) == 0) {
			++n;
		}
	}
	g = createGraph(n + 1, gp);

	/* create tree from canonical string recursively */
	g->vertices[0]->label = pattern->edges->label;
	pattern->edges = pattern->edges->next;
	__canonicalString2GraphRec(g, 1, 0, pattern, initEdge, termEdge, gp);
	pattern->edges = head;

	/* cleanup */
	dumpVertexList(gp->listPool, initEdge);
	dumpVertexList(gp->listPool, termEdge);

	return g;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x38(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x9000
movq %rax, 0x30(%rsp)
movq 0x38(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x8fc0
movq %rax, 0x28(%rsp)
movl $0x0, 0x1c(%rsp)
movq 0x40(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0xa185
movq 0x20(%rsp), %rax
movq (%rax), %rdi
movq 0x30(%rsp), %rax
movq (%rax), %rsi
callq 0x1120
cmpl $0x0, %eax
jne 0xa173
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0xa175
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0xa146
movl 0x1c(%rsp), %edi
addl $0x1, %edi
movq 0x38(%rsp), %rsi
callq 0xb850
movq %rax, 0x10(%rsp)
movq 0x40(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rcx
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq %rcx, (%rax)
movq 0x40(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rcx
movq 0x40(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rdi
movq 0x40(%rsp), %rcx
movq 0x30(%rsp), %r8
movq 0x28(%rsp), %r9
movq 0x38(%rsp), %rax
movl $0x1, %esi
xorl %edx, %edx
movq %rax, (%rsp)
callq 0x9fa0
movq 0x8(%rsp), %rcx
movq 0x40(%rsp), %rax
movq %rcx, (%rax)
movq 0x38(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x30(%rsp), %rsi
callq 0x1f410
movq 0x38(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x28(%rsp), %rsi
callq 0x1f410
movq 0x10(%rsp), %rax
addq $0x48, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/cs_Tree.c
// Function: treeCanonicalString2ExistingGraph
void treeCanonicalString2ExistingGraph(struct ShallowGraph* pattern, struct Graph* g, struct GraphPool* gp) {
	struct VertexList* initEdge = getInitialisatorEdge(gp->listPool);
	struct VertexList* termEdge = getTerminatorEdge(gp->listPool);
	struct VertexList* head = pattern->edges;

	/* create tree from canonical string recursively */
	g->vertices[0]->label = pattern->edges->label;
	pattern->edges = pattern->edges->next;
	__canonicalString2GraphRec(g, 1, 0, pattern, initEdge, termEdge, gp);
	pattern->edges = head;

	/* cleanup */
	dumpVertexList(gp->listPool, initEdge);
	dumpVertexList(gp->listPool, termEdge);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x9000
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x8fc0
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rcx
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq %rcx, (%rax)
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rcx
movq 0x30(%rsp), %rax
movq %rcx, (%rax)
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rcx
movq 0x18(%rsp), %r8
movq 0x10(%rsp), %r9
movq 0x20(%rsp), %rax
movl $0x1, %esi
xorl %edx, %edx
movq %rax, (%rsp)
callq 0x9fa0
movq 0x8(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, (%rax)
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x18(%rsp), %rsi
callq 0x1f410
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x10(%rsp), %rsi
callq 0x1f410
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/graph.c
// Function: shallowCopyEdge
struct VertexList* shallowCopyEdge(struct VertexList* e, struct ListPool* p) {
	struct VertexList* f = getVertexList(p);
	f->startPoint = e->startPoint;
	f->endPoint = e->endPoint;
	f->label = e->label;
	/* f does not manage its string but refers to a different lists string, thus it is no stringMaster */
	return f;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x1f310
movq %rax, (%rsp)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rcx
movq (%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/graph.c
// Function: shallowCopyVertex
struct Vertex* shallowCopyVertex(struct Vertex *v, struct VertexPool *p) {
	struct Vertex *new = getVertex(p);
	new->number = v->number;
	new->label = v->label;
	return new;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x1f6a0
movq %rax, (%rsp)
movq 0x10(%rsp), %rax
movl 0x18(%rax), %ecx
movq (%rsp), %rax
movl %ecx, 0x18(%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/graph.c
// Function: degree
int degree(struct Vertex* v) {
	struct VertexList* e;
	int deg = 0;
	for (e=v->neighborhood; e!=NULL; e=e->next) {
		++deg;
	}
	return deg;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl $0x0, -0x14(%rsp)
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rsp)
cmpq $0x0, -0x10(%rsp)
je 0xa47e
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rsp)
jmp 0xa45b
movl -0x14(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/graph.c
// Function: isLeaf
char isLeaf(struct Vertex* v) {
	/* check if v has a neigbor at all */
	if (v->neighborhood) {
		/* check if v has exactly one neighbor, thus is a leaf */
		if (v->neighborhood->next == NULL) {
			return 1;
		} else {
			return 0;
		}
	} else {
		return 0;
	}
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq -0x10(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0xa4bf
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
cmpq $0x0, 0x8(%rax)
jne 0xa4b8
movb $0x1, -0x1(%rsp)
jmp 0xa4c4
movb $0x0, -0x1(%rsp)
jmp 0xa4c4
movb $0x0, -0x1(%rsp)
movb -0x1(%rsp), %al
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/graph.c
// Function: commonNeighborCount
int commonNeighborCount(struct Vertex* v, struct Vertex* w) {
	struct VertexList* e;
	int count = 0;

	for (e=v->neighborhood; e; e=e->next) {
		e->endPoint->visited = 1;
	}
	for (e=w->neighborhood; e; e=e->next) {
		/* if the endpoint is visited, then there is a triangle
		 * if there are more than two triangles, break */
		if (e->endPoint->visited) {
			++count;
		}
	}
	for (e=v->neighborhood; e; e=e->next) {
		e->endPoint->visited = 0;
	}
	return count;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movl $0x0, -0x1c(%rsp)
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rsp)
cmpq $0x0, -0x18(%rsp)
je 0xa518
movq -0x18(%rsp), %rax
movq 0x18(%rax), %rax
movl $0x1, 0x1c(%rax)
movq -0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rsp)
jmp 0xa4f0
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rsp)
cmpq $0x0, -0x18(%rsp)
je 0xa55a
movq -0x18(%rsp), %rax
movq 0x18(%rax), %rax
cmpl $0x0, 0x1c(%rax)
je 0xa548
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0xa54a
movq -0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rsp)
jmp 0xa526
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rsp)
cmpq $0x0, -0x18(%rsp)
je 0xa590
movq -0x18(%rsp), %rax
movq 0x18(%rax), %rax
movl $0x0, 0x1c(%rax)
movq -0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rsp)
jmp 0xa568
movl -0x1c(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/graph.c
// Function: isIncident
char isIncident(struct Vertex* v, struct Vertex* w) {
	struct VertexList* e;

	for (e=v->neighborhood; e; e=e->next) {
		if (e->endPoint == w) {
			return 1;
		}
	}

	return 0;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rsp)
cmpq $0x0, -0x20(%rsp)
je 0xa5e9
movq -0x20(%rsp), %rax
movq 0x18(%rax), %rax
cmpq -0x18(%rsp), %rax
jne 0xa5d7
movb $0x1, -0x1(%rsp)
jmp 0xa5ee
jmp 0xa5d9
movq -0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rsp)
jmp 0xa5b8
movb $0x0, -0x1(%rsp)
movb -0x1(%rsp), %al
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/graph.c
// Function: isDegreeTwoVertex
char isDegreeTwoVertex(struct Vertex* v) {
	struct VertexList* idx;
	int delta = 0;

	/* check if the current vertex is of degree 2. */
	for (idx=v->neighborhood; idx; idx=idx->next) {
		if (delta < 3) {
			++delta;
		} else {
			break;
		}
	}

	return (delta == 2);
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl $0x0, -0x14(%rsp)
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rsp)
cmpq $0x0, -0x10(%rsp)
je 0xa64b
cmpl $0x3, -0x14(%rsp)
jge 0xa637
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0xa639
jmp 0xa64b
jmp 0xa63b
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rsp)
jmp 0xa61b
cmpl $0x2, -0x14(%rsp)
sete %al
andb $0x1, %al
movzbl %al, %eax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/graph.c
// Function: removeEdge
void removeEdge(struct Vertex* v, struct Vertex* w, struct ListPool* p) {
	struct VertexList* idx, *tmp;

	if (v->neighborhood->endPoint == w) {
		tmp = v->neighborhood;
		v->neighborhood = v->neighborhood->next;
		dumpVertexList(p, tmp);
		return;
	}

	tmp = v->neighborhood;
	for (idx=tmp->next; idx; idx=idx->next, tmp=tmp->next) {
		if (idx->endPoint == w) {
			tmp->next = idx->next;
			dumpVertexList(p, idx);
			return;
		}
	}
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rax
cmpq 0x18(%rsp), %rax
jne 0xa6fa
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rdi
movq (%rsp), %rsi
callq 0x1f410
jmp 0xa76c
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0xa76c
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
cmpq 0x18(%rsp), %rax
jne 0xa74e
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x1f410
jmp 0xa76c
jmp 0xa750
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
jmp 0xa714
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/graph.c
// Function: snatchEdge
struct VertexList* snatchEdge(struct Vertex* v, struct Vertex* w) {
	struct VertexList* idx, *tmp;

	if (v->neighborhood->endPoint == w) {
		tmp = v->neighborhood;
		v->neighborhood = v->neighborhood->next;	
		tmp->next = NULL;
		return tmp;
	}

	tmp = v->neighborhood;
	for (idx=tmp->next; idx; idx=idx->next, tmp=tmp->next) {
		if (idx->endPoint == w) {
			tmp->next = idx->next;
			idx->next = NULL;
			return idx;
		}
	}
	return NULL;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rax
cmpq -0x18(%rsp), %rax
jne 0xa7de
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rsp)
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rsp), %rax
movq $0x0, 0x8(%rax)
movq -0x28(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0xa866
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rsp)
movq -0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rsp)
cmpq $0x0, -0x20(%rsp)
je 0xa85d
movq -0x20(%rsp), %rax
movq 0x18(%rax), %rax
cmpq -0x18(%rsp), %rax
jne 0xa83d
movq -0x20(%rsp), %rax
movq 0x8(%rax), %rcx
movq -0x28(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rsp), %rax
movq $0x0, 0x8(%rax)
movq -0x20(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0xa866
jmp 0xa83f
movq -0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rsp)
movq -0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rsp)
jmp 0xa7fa
movq $0x0, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/graph.c
// Function: mergeGraphs
struct Graph* mergeGraphs(struct Graph* g, struct GraphPool* gp) {
	int n = 0;
	int m = 0;
	int i = 0;
	struct Graph* current;
	struct Graph* bigGraph = getGraph(gp);

	for (current=g; current!=NULL; current=current->next) {
		n += current->n;
		m += current->m;
	}
	setVertexNumber(bigGraph, n);
	bigGraph->m = m;

	for (current=g; current!=NULL; current=current->next) {
		int v;
		for (v=0; v<current->n; ++v, ++i) {
			bigGraph->vertices[i] = current->vertices[v];
			bigGraph->vertices[i]->number = i;
			current->vertices[v] = NULL;
		}
	}
	for (current=g; current!=NULL; ) {
		struct Graph* tmp = current;
		current = current->next;
		tmp->next = NULL;
		dumpGraph(gp, tmp);
	}
	return bigGraph;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movl $0x0, 0x34(%rsp)
movl $0x0, 0x30(%rsp)
movl $0x0, 0x2c(%rsp)
movq 0x38(%rsp), %rdi
callq 0x1fa40
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0xa8e6
movq 0x20(%rsp), %rax
movl (%rax), %eax
addl 0x34(%rsp), %eax
movl %eax, 0x34(%rsp)
movq 0x20(%rsp), %rax
movl 0x4(%rax), %eax
addl 0x30(%rsp), %eax
movl %eax, 0x30(%rsp)
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0xa8af
movq 0x18(%rsp), %rdi
movl 0x34(%rsp), %esi
callq 0xaa00
movl 0x30(%rsp), %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x4(%rax)
movq 0x40(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0xa9ab
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl (%rcx), %eax
jge 0xa996
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rdx
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x2c(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl 0x2c(%rsp), %ecx
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x2c(%rsp), %rdx
movq (%rax,%rdx,8), %rax
movl %ecx, 0x18(%rax)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x14(%rsp), %rcx
movq $0x0, (%rax,%rcx,8)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0xa91e
jmp 0xa998
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0xa90a
movq 0x40(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0xa9f3
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x8(%rsp), %rax
movq $0x0, 0x18(%rax)
movq 0x38(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x1fb30
jmp 0xa9b5
movq 0x18(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/graph.c
// Function: setVertexNumber
struct Vertex** setVertexNumber(struct Graph* g, int n) {
	int i;
	
	if (n<0) {
		printf("Error allocating memory for array of negative size %i\n", n);
		return NULL;
	}
	
	g->n = n;
	g->vertices = malloc(n * sizeof(struct Vertex*));

	for (i=0; i<n; ++i) {
		g->vertices[i] = NULL;
	}

	return g->vertices;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movl %esi, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jge 0xaa31
movl 0x4(%rsp), %esi
leaq 0x2a7df(%rip), %rdi     # 0x351fe
movb $0x0, %al
callq 0x1090
movq $0x0, 0x10(%rsp)
jmp 0xaa94
movl 0x4(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, (%rax)
movslq 0x4(%rsp), %rdi
shlq $0x3, %rdi
callq 0x1170
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movl $0x0, (%rsp)
movl (%rsp), %eax
cmpl 0x4(%rsp), %eax
jge 0xaa86
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movslq (%rsp), %rcx
movq $0x0, (%rax,%rcx,8)
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0xaa5d
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/graph.c
// Function: deleteEdge
struct VertexList* deleteEdge(struct Graph* g, int v, int w) {
	struct VertexList* e = g->vertices[v]->neighborhood;
	struct VertexList* f = e->next;

	if (e->endPoint->number == w) {
		g->vertices[v]->neighborhood = e->next;
		e->next = NULL;
		return e;
	}

	for ( ; f!=NULL; e=f, f=f->next) {
		if (f->endPoint->number == w) {
			e->next = f->next;
			f->next = NULL;
			return f;
		}
	}
	/* returns NULL, if there is no edge between v and w */
	return NULL;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
movl %edx, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq 0x10(%rax), %rax
movslq -0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rsp)
movq -0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rsp)
movq -0x20(%rsp), %rax
movq 0x18(%rax), %rax
movl 0x18(%rax), %eax
cmpl -0x18(%rsp), %eax
jne 0xab20
movq -0x20(%rsp), %rax
movq 0x8(%rax), %rcx
movq -0x10(%rsp), %rax
movq 0x10(%rax), %rax
movslq -0x14(%rsp), %rdx
movq (%rax,%rdx,8), %rax
movq %rcx, 0x8(%rax)
movq -0x20(%rsp), %rax
movq $0x0, 0x8(%rax)
movq -0x20(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0xab8c
jmp 0xab22
cmpq $0x0, -0x28(%rsp)
je 0xab83
movq -0x28(%rsp), %rax
movq 0x18(%rax), %rax
movl 0x18(%rax), %eax
cmpl -0x18(%rsp), %eax
jne 0xab67
movq -0x28(%rsp), %rax
movq 0x8(%rax), %rcx
movq -0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x28(%rsp), %rax
movq $0x0, 0x8(%rax)
movq -0x28(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0xab8c
jmp 0xab69
movq -0x28(%rsp), %rax
movq %rax, -0x20(%rsp)
movq -0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rsp)
jmp 0xab22
movq $0x0, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/graph.c
// Function: deleteEdgeBetweenVertices
void deleteEdgeBetweenVertices(struct Graph* g, struct VertexList* idx, struct GraphPool* gp) {
	struct VertexList* tmp = deleteEdge(g, idx->startPoint->number, idx->endPoint->number);
	dumpVertexList(gp->listPool, tmp);
	tmp = deleteEdge(g, idx->endPoint->number, idx->startPoint->number);
	if (tmp != NULL) {
		--(g->m);
	}
	dumpVertexList(gp->listPool, tmp);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movl 0x18(%rax), %esi
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rax
movl 0x18(%rax), %edx
callq 0xaaa0
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0x1f410
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rax
movl 0x18(%rax), %esi
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movl 0x18(%rax), %edx
callq 0xaaa0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0xac2a
movq 0x20(%rsp), %rax
movl 0x4(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x4(%rax)
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0x1f410
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/graph.c
// Function: isNeighbor
char isNeighbor(struct Graph* g, int v, int w) {
	struct VertexList* e;
	if ((g->vertices[v]) && (g->vertices[v]->neighborhood)) {
		for (e=g->vertices[v]->neighborhood; e!=NULL; e=e->next) {
			if (e->endPoint->number == w) {
				return 1;
			}
		}
	}
	/* if there is no vertex, or no neighborhood at all, or w does not occur
	as endpoint of any edge incident to v, return false */
	return 0;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
movl %edx, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq 0x10(%rax), %rax
movslq -0x14(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0xb51b
movq -0x10(%rsp), %rax
movq 0x10(%rax), %rax
movslq -0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rax
cmpq $0x0, 0x8(%rax)
je 0xb51b
movq -0x10(%rsp), %rax
movq 0x10(%rax), %rax
movslq -0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rsp)
cmpq $0x0, -0x20(%rsp)
je 0xb519
movq -0x20(%rsp), %rax
movq 0x18(%rax), %rax
movl 0x18(%rax), %eax
cmpl -0x18(%rsp), %eax
jne 0xb507
movb $0x1, -0x1(%rsp)
jmp 0xb520
jmp 0xb509
movq -0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rsp)
jmp 0xb4e6
jmp 0xb51b
movb $0x0, -0x1(%rsp)
movb -0x1(%rsp), %al
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/graph.c
// Function: getGraphEdges
struct ShallowGraph* getGraphEdges(struct Graph *g, struct ShallowGraphPool* sgp) {
	int i;
	struct ShallowGraph* edges = getShallowGraph(sgp);
	for (i=0; i<g->n; ++i) {
		if (g->vertices[i]) {
			struct VertexList *idx;
			for (idx = g->vertices[i]->neighborhood; idx; idx = idx->next) {
				if (idx->endPoint->number > i) {
					pushEdge(edges, shallowCopyEdge(idx, sgp->listPool));
				}
			}
		}
	}

	return edges;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x1fe70
movq %rax, 0x18(%rsp)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
movq 0x30(%rsp), %rcx
cmpl (%rcx), %eax
jge 0xb600
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x24(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0xb5ee
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x24(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0xb5ec
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movl 0x18(%rax), %eax
cmpl 0x24(%rsp), %eax
jle 0xb5da
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0xa310
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0xb610
jmp 0xb5dc
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0xb596
jmp 0xb5ee
jmp 0xb5f0
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0xb555
movq 0x18(%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/graph.c
// Function: pushEdge
void pushEdge(struct ShallowGraph *g, struct VertexList *e) {

	g->edges = push(g->edges, e);
	if (g->lastEdge == NULL) {
		g->lastEdge = e;
	}
	++g->m;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0xa3d0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0xb655
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
movl 0x10(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x10(%rax)
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/graph.c
// Function: addEdgeBetweenVertices
void addEdgeBetweenVertices(int v, int w, char* label, struct Graph* g, struct GraphPool* gp) {
	struct VertexList* e = getVertexList(gp->listPool);
	e->startPoint = g->vertices[v];
	e->endPoint = g->vertices[w];
	e->label = label;

	addEdge(g->vertices[v], e);
	addEdge(g->vertices[w], inverseEdge(e, gp->listPool));

	++(g->m);
}

// Assembly:
subq $0x38, %rsp
movl %edi, 0x34(%rsp)
movl %esi, 0x30(%rsp)
movq %rdx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movq %r8, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x1f310
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x34(%rsp), %rcx
movq (%rax,%rcx,8), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x30(%rsp), %rcx
movq (%rax,%rcx,8), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x28(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x34(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x10(%rsp), %rsi
callq 0xa660
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x30(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rsi
callq 0xa370
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0xa660
movq 0x20(%rsp), %rax
movl 0x4(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x4(%rax)
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/graph.c
// Function: emptyGraph
struct Graph* emptyGraph(struct Graph* g, struct GraphPool* gp) {
	struct Graph* empty = getGraph(gp);
	int v;
	setVertexNumber(empty, g->n);

	for (v=0; v<g->n; ++v) {
		empty->vertices[v] = shallowCopyVertex(g->vertices[v], gp->vertexPool);
	}
	return empty;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x1fa40
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rax
movl (%rax), %esi
callq 0xaa00
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl (%rcx), %eax
jge 0xb845
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0xa3f0
movq %rax, %rdx
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0xc(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0xb7f6
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/graph.c
// Function: createGraph
struct Graph* createGraph(int n, struct GraphPool* gp) {
	struct Graph* empty = getGraph(gp);
	int v;
	setVertexNumber(empty, n);

	for (v=0; v<n; ++v) {
		empty->vertices[v] = getVertex(gp->vertexPool);
		empty->vertices[v]->number = v;
	}
	return empty;
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x24(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x1fa40
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl 0x24(%rsp), %esi
callq 0xaa00
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x24(%rsp), %eax
jge 0xb8d5
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x1f6a0
movq %rax, %rdx
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0xc(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl 0xc(%rsp), %ecx
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0xc(%rsp), %rdx
movq (%rax,%rdx,8), %rax
movl %ecx, 0x18(%rax)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0xb882
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/graph.c
// Function: getMaxDegree
int getMaxDegree(struct Graph* g) {
	int max = -1;
	int v;
	for (v=0; v<g->n; ++v) {
		if (g->vertices[v] != NULL) {
			int deg = degree(g->vertices[v]);
			if (max < deg) {
				max = deg;
			}
		}
	}
	return max;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0xffffffff, 0xc(%rsp)  # imm = 0xFFFFFFFF
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl (%rcx), %eax
jge 0xb959
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x8(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0xb94a
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0xa440
movl %eax, 0x4(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x4(%rsp), %eax
jge 0xb948
movl 0x4(%rsp), %eax
movl %eax, 0xc(%rsp)
jmp 0xb94a
jmp 0xb94c
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0xb8f9
movl 0xc(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/graph.c
// Function: getMinDegree
int getMinDegree(struct Graph* g) {
	int min = INT_MAX;
	int v;
	for (v=0; v<g->n; ++v) {
		if (g->vertices[v] != NULL) {
			int deg = degree(g->vertices[v]);
			if (min > deg) {
				min = deg;
			}
		}
	}
	return min;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x7fffffff, 0xc(%rsp)  # imm = 0x7FFFFFFF
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl (%rcx), %eax
jge 0xb9e9
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x8(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0xb9da
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0xa440
movl %eax, 0x4(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x4(%rsp), %eax
jle 0xb9d8
movl 0x4(%rsp), %eax
movl %eax, 0xc(%rsp)
jmp 0xb9da
jmp 0xb9dc
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0xb989
movl 0xc(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/graph.c
// Function: popGraph
struct Graph* popGraph(struct Graph** list) {
	struct Graph* head = *list;
	if (head != NULL) {
		*list = head->next;
		head->next = NULL;
	}
	return head;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rsp)
cmpq $0x0, -0x10(%rsp)
je 0xba38
movq -0x10(%rsp), %rax
movq 0x18(%rax), %rcx
movq -0x8(%rsp), %rax
movq %rcx, (%rax)
movq -0x10(%rsp), %rax
movq $0x0, 0x18(%rax)
movq -0x10(%rsp), %rax
retq
nop