LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/graph.c
// Function: canonicalizeShallowGraphCached
void canonicalizeShallowGraphCached(struct ShallowGraph* g, struct VertexList** edgePointers) {
	int i=0;
	for (struct VertexList* e=g->edges; e!=NULL; e=e->next) {
		edgePointers[i] = e;
		++i;
	}

	qsort(edgePointers, sizeof(struct VertexList*), g->m, edgeCmp);

	for (i=0; i<g->m-1; ++i) {
		edgePointers[i]->next = edgePointers[i+1];
	}
	edgePointers[g->m-1]->next = NULL;
	g->edges = edgePointers[0];

}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0xba99
movq 0x8(%rsp), %rdx
movq 0x18(%rsp), %rax
movslq 0x14(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0xba63
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rax
movslq 0x10(%rax), %rdx
movl $0x8, %esi
leaq 0x8d(%rip), %rcx        # 0xbb40
callq 0x1060
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq 0x20(%rsp), %rcx
movl 0x10(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0xbb05
movq 0x18(%rsp), %rax
movl 0x14(%rsp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rcx
movq 0x18(%rsp), %rax
movslq 0x14(%rsp), %rdx
movq (%rax,%rdx,8), %rax
movq %rcx, 0x8(%rax)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0xbac0
movq 0x18(%rsp), %rax
movq 0x20(%rsp), %rcx
movl 0x10(%rcx), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq $0x0, 0x8(%rax)
movq 0x18(%rsp), %rax
movq (%rax), %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/graph.c
// Function: edgeCmp
static int edgeCmp(const void* a, const void* b) {
	struct VertexList* e = *(struct VertexList**)a;
	struct VertexList* f = *(struct VertexList**)b;

	int x = e->startPoint->number - f->startPoint->number;
	int y = e->endPoint->number - f->endPoint->number;

	return x == 0 ? y : x;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rsp)
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rsp)
movq -0x18(%rsp), %rax
movq 0x10(%rax), %rax
movl 0x18(%rax), %eax
movq -0x20(%rsp), %rcx
movq 0x10(%rcx), %rcx
subl 0x18(%rcx), %eax
movl %eax, -0x24(%rsp)
movq -0x18(%rsp), %rax
movq 0x18(%rax), %rax
movl 0x18(%rax), %eax
movq -0x20(%rsp), %rcx
movq 0x18(%rcx), %rcx
subl 0x18(%rcx), %eax
movl %eax, -0x28(%rsp)
cmpl $0x0, -0x24(%rsp)
jne 0xbbad
movl -0x28(%rsp), %eax
movl %eax, -0x2c(%rsp)
jmp 0xbbb5
movl -0x24(%rsp), %eax
movl %eax, -0x2c(%rsp)
movl -0x2c(%rsp), %eax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/graph.c
// Function: rebaseShallowGraphs
void rebaseShallowGraphs(struct ShallowGraph* list, struct Graph* newBase) {
	struct ShallowGraph* idx;
	struct VertexList* e;

	for (idx=list; idx!=NULL; idx=idx->next) {
		for (e=idx->edges; e!=NULL; e=e->next) {
			e->startPoint = newBase->vertices[e->startPoint->number];
			e->endPoint = newBase->vertices[e->endPoint->number];
		}
	}
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x18(%rsp)
cmpq $0x0, -0x18(%rsp)
je 0xbca0
movq -0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rsp)
cmpq $0x0, -0x20(%rsp)
je 0xbc8b
movq -0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq -0x20(%rsp), %rcx
movq 0x10(%rcx), %rcx
movslq 0x18(%rcx), %rcx
movq (%rax,%rcx,8), %rcx
movq -0x20(%rsp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq -0x20(%rsp), %rcx
movq 0x18(%rcx), %rcx
movslq 0x18(%rcx), %rcx
movq (%rax,%rcx,8), %rcx
movq -0x20(%rsp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rsp)
jmp 0xbc2d
jmp 0xbc8d
movq -0x18(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rsp)
jmp 0xbc14
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/graph.c
// Function: rebaseShallowGraphsOnLowPoints
void rebaseShallowGraphsOnLowPoints(struct ShallowGraph* list, struct Graph* newBase) {
	struct ShallowGraph* idx;
	struct VertexList* e;

	for (idx=list; idx!=NULL; idx=idx->next) {
		for (e=idx->edges; e!=NULL; e=e->next) {
			e->startPoint = newBase->vertices[e->startPoint->lowPoint];
			e->endPoint = newBase->vertices[e->endPoint->lowPoint];
		}
	}
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
movq %rax, -0x18(%rsp)
cmpq $0x0, -0x18(%rsp)
je 0xbd50
movq -0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rsp)
cmpq $0x0, -0x20(%rsp)
je 0xbd3b
movq -0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq -0x20(%rsp), %rcx
movq 0x10(%rcx), %rcx
movslq 0x20(%rcx), %rcx
movq (%rax,%rcx,8), %rcx
movq -0x20(%rsp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq -0x20(%rsp), %rcx
movq 0x18(%rcx), %rcx
movslq 0x20(%rcx), %rcx
movq (%rax,%rcx,8), %rcx
movq -0x20(%rsp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rsp)
jmp 0xbcdd
jmp 0xbd3d
movq -0x18(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rsp)
jmp 0xbcc4
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/graph.c
// Function: addComponent
struct ShallowGraph* addComponent(struct ShallowGraph* g, struct ShallowGraph* h) {
	/* if g and h are both cycles, concatenate them */
	if (g && h) {	
		struct ShallowGraph* tmp = g->prev;
	
		g->prev->next = h;
		g->prev = h->prev;
		h->prev->next = g;
		h->prev = tmp;
		return g;
	} else {
		/* if one of the two inputs is NULL, return the other without change */
		return (g) ? g : h;
	}
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
cmpq $0x0, -0x10(%rsp)
je 0xbdd8
cmpq $0x0, -0x18(%rsp)
je 0xbdd8
movq -0x10(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rsp)
movq -0x18(%rsp), %rcx
movq -0x10(%rsp), %rax
movq 0x20(%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rsp), %rax
movq 0x20(%rax), %rcx
movq -0x10(%rsp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rsp), %rcx
movq -0x18(%rsp), %rax
movq 0x20(%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rsp), %rcx
movq -0x18(%rsp), %rax
movq %rcx, 0x20(%rax)
movq -0x10(%rsp), %rax
movq %rax, -0x8(%rsp)
jmp 0xbe00
cmpq $0x0, -0x10(%rsp)
je 0xbdec
movq -0x10(%rsp), %rax
movq %rax, -0x28(%rsp)
jmp 0xbdf6
movq -0x18(%rsp), %rax
movq %rax, -0x28(%rsp)
movq -0x28(%rsp), %rax
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/graph.c
// Function: cloneShallowGraph
struct ShallowGraph* cloneShallowGraph(struct ShallowGraph* g, struct ShallowGraphPool* sgp) {
	struct ShallowGraph* copy = getShallowGraph(sgp);
	struct VertexList* edgeList = NULL;
	struct VertexList* e;
	int m = 0;
	for (e=g->edges; e!=NULL; e=e->next) {
		if (edgeList == NULL) {
			edgeList = shallowCopyEdge(e, sgp->listPool);
			copy->edges = edgeList;
		} else {
			edgeList->next = shallowCopyEdge(e, sgp->listPool);
			edgeList = edgeList->next;
		}
		++m;
	}
	copy->lastEdge = edgeList;
	copy->m = m;

	return copy;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x1fe70
movq %rax, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movl $0x0, 0xc(%rsp)
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0xbeca
cmpq $0x0, 0x18(%rsp)
jne 0xbe82
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0xa310
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
jmp 0xbeaf
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0xa310
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0xbe4b
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
movl 0xc(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x10(%rax)
movq 0x20(%rsp), %rax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/graph.c
// Function: popEdge
struct VertexList* popEdge(struct ShallowGraph* g) {
	struct VertexList* e = g->edges;
	if (g->edges) {
		g->edges = g->edges->next;
		--g->m;
		if (g->edges == NULL) {
			g->lastEdge = NULL;
		}
	}
	if (e != NULL) {
		e->next = NULL;
	}
	return e;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rsp)
movq -0x8(%rsp), %rax
cmpq $0x0, (%rax)
je 0xbf49
movq -0x8(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rsp), %rax
movq %rcx, (%rax)
movq -0x8(%rsp), %rax
movl 0x10(%rax), %ecx
addl $-0x1, %ecx
movl %ecx, 0x10(%rax)
movq -0x8(%rsp), %rax
cmpq $0x0, (%rax)
jne 0xbf47
movq -0x8(%rsp), %rax
movq $0x0, 0x8(%rax)
jmp 0xbf49
cmpq $0x0, -0x10(%rsp)
je 0xbf5e
movq -0x10(%rsp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/graph.c
// Function: appendEdge
void appendEdge(struct ShallowGraph *g, struct VertexList *e) {

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

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0xbfb7
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0xa3d0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
jmp 0xbfe4
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x8(%rax)
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
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/graph.c
// Function: assertLastPointer
struct VertexList* assertLastPointer(struct ShallowGraph* g) {
	struct VertexList* idx;

	/* if lastedge is not initialized, set it to the first edge. */
	if (g->lastEdge == NULL) {
		g->lastEdge = g->edges;
	}

	/* move lastedge pointer to the end of the list */
	for (idx=g->lastEdge; idx; idx=idx->next) {
			g->lastEdge = idx;
	}

	return g->lastEdge;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0xc022
movq -0x8(%rsp), %rax
movq (%rax), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rsp)
cmpq $0x0, -0x10(%rsp)
je 0xc056
movq -0x10(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x10(%rsp)
jmp 0xc030
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
retq
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/graph.c
// Function: inverseCycle
struct ShallowGraph* inverseCycle(struct ShallowGraph* cycle, struct ShallowGraphPool *sgp) {
	struct VertexList *index;
	struct ShallowGraph* inverse = getShallowGraph(sgp);


	for (index=cycle->edges; index; index=index->next) {
		struct VertexList* e = inverseEdge(index, sgp->listPool);
		pushEdge(inverse, e);

		/* set lastEdge pointer to the correct value */
		if (index == cycle->edges) {
			inverse->lastEdge = e;
		}
	}

	return inverse;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
callq 0x1fe70
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0xc0e5
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0xa370
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
callq 0xb610
movq 0x10(%rsp), %rax
movq 0x20(%rsp), %rcx
cmpq (%rcx), %rax
jne 0xc0d3
movq (%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
jmp 0xc0d5
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0xc08a
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/graphPrinting.c
// Function: printGraphAidsFormat
void printGraphAidsFormat(struct Graph* g, FILE* out) {
	int i;
	// print header line
	fprintf(out, "# %i %i %i %i\n", g->number, g->activity, g->n, g->m);

	// print vertex labels
	for (i=0; i<g->n; ++i) {
		fprintf(out, "%s ", g->vertices[i]->label);
	}
	fputc('\n', out);

	// print edges
	for (i=0; i<g->n; ++i) {
		struct VertexList* e;
		for (e=g->vertices[i]->neighborhood; e!=NULL; e=e->next) {
			if (e->startPoint->number < e->endPoint->number) {
				fprintf(out, "%i %i %s ", e->startPoint->number + 1, e->endPoint->number + 1, e->label);
			}
		}
	}
	fputc('\n', out);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rax
movl 0x8(%rax), %edx
movq 0x20(%rsp), %rax
movl 0xc(%rax), %ecx
movq 0x20(%rsp), %rax
movl (%rax), %r8d
movq 0x20(%rsp), %rax
movl 0x4(%rax), %r9d
leaq 0x2910a(%rip), %rsi     # 0x35235
movb $0x0, %al
callq 0x1140
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl (%rcx), %eax
jge 0xc17c
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rdx
leaq 0x290e2(%rip), %rsi     # 0x3524a
movb $0x0, %al
callq 0x1140
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0xc13a
movq 0x18(%rsp), %rsi
movl $0xa, %edi
callq 0x10f0
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl (%rcx), %eax
jge 0xc23e
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0xc22c
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movl 0x18(%rax), %eax
movq 0x8(%rsp), %rcx
movq 0x18(%rcx), %rcx
cmpl 0x18(%rcx), %eax
jge 0xc21a
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movl 0x18(%rax), %edx
addl $0x1, %edx
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movl 0x18(%rax), %ecx
addl $0x1, %ecx
movq 0x8(%rsp), %rax
movq (%rax), %r8
leaq 0x29031(%rip), %rsi     # 0x35244
movb $0x0, %al
callq 0x1140
jmp 0xc21c
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0xc1bf
jmp 0xc22e
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0xc193
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/graphPrinting.c
// Function: printShallowGraph
void printShallowGraph(struct ShallowGraph* g) {
	
	struct ShallowGraph* index = g;
	int i = 0;
	do {
		if (index) {
			printf("Graph %i has %i edges:\n", i, index->m);
			printVertexList(index->edges);
			printf("\n");
			index = index->next;
			++i;
		} else {
			/* if index is NULL, the input pointed to a list and not to a cycle */
			break;
		}
	} while (index != g);
	fflush(stdout);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0xc2d3
movl 0x4(%rsp), %esi
movq 0x8(%rsp), %rax
movl 0x10(%rax), %edx
leaq 0x28fb8(%rip), %rdi     # 0x3524e
movb $0x0, %al
callq 0x1090
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0xc300
leaq 0x28e04(%rip), %rdi     # 0x350b5
movb $0x0, %al
callq 0x1090
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%rsp)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0xc2d5
jmp 0xc2e3
jmp 0xc2d7
movq 0x8(%rsp), %rax
cmpq 0x10(%rsp), %rax
jne 0xc27b
movq 0x31cde(%rip), %rax     # 0x3dfc8
movq (%rax), %rdi
callq 0x1180
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/graphPrinting.c
// Function: printVertexList
void printVertexList(struct VertexList *f) {
	struct VertexList* e;
	for (e=f; e; e=e->next) {
		printf("(%i, %i)", e->startPoint->number, e->endPoint->number);
		fflush(stdout);
		printf(" %s\n", e->label);
	}
	fflush(stdout);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0xc376
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movl 0x18(%rax), %esi
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movl 0x18(%rax), %edx
leaq 0x29043(%rip), %rdi     # 0x3537d
movb $0x0, %al
callq 0x1090
movq 0x31c80(%rip), %rax     # 0x3dfc8
movq (%rax), %rdi
callq 0x1180
movq 0x8(%rsp), %rax
movq (%rax), %rsi
leaq 0x29cae(%rip), %rdi     # 0x3600d
movb $0x0, %al
callq 0x1090
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0xc313
movq 0x31c4b(%rip), %rax     # 0x3dfc8
movq (%rax), %rdi
callq 0x1180
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/graphPrinting.c
// Function: printLabelledShallowGraph
void printLabelledShallowGraph(struct ShallowGraph* g) {
	
	struct ShallowGraph* index = g;
	int i = 0;
	do {
		if (index) {
			struct VertexList* e;
			printf("Graph %i has %i edges:\n", i, index->m);
			for (e=index->edges; e!=NULL; e=e->next) {
				printf("(%s)%s(%s)\n",e->startPoint->label, e->label, e->endPoint->label);
			}
			printf("\n");
			index = index->next;
			++i;
		} else {
			/* if index is NULL, the input pointed to a list and not to a cycle */
			break;
		}
	} while (index != g);
	fflush(stdout);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0xc44d
movl 0x14(%rsp), %esi
movq 0x18(%rsp), %rax
movl 0x10(%rax), %edx
leaq 0x28e84(%rip), %rdi     # 0x3524e
movb $0x0, %al
callq 0x1090
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0xc424
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rsi
movq 0x8(%rsp), %rax
movq (%rax), %rdx
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq (%rax), %rcx
leaq 0x28e59(%rip), %rdi     # 0x35266
movb $0x0, %al
callq 0x1090
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0xc3de
leaq 0x28c8a(%rip), %rdi     # 0x350b5
movb $0x0, %al
callq 0x1090
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0xc44f
jmp 0xc461
jmp 0xc451
movq 0x18(%rsp), %rax
cmpq 0x20(%rsp), %rax
jne 0xc3ab
movq 0x31b60(%rip), %rax     # 0x3dfc8
movq (%rax), %rdi
callq 0x1180
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/graphPrinting.c
// Function: printShallowGraphCount
int printShallowGraphCount(struct ShallowGraph* g, char silent) {

	struct ShallowGraph* index = g;
	int i = 0;
	do {
		if (index) {
			index = index->next;
			++i;
		} else {
			/* if index is NULL, the input pointed to a list and not to a cycle */
			break;
		}
	} while (index != g);

	if (!silent) {
		printf("Result contains %i structures\n", i);
		fflush(stdout);
	}
	
	return i;

}

// Assembly:
subq $0x28, %rsp
movb %sil, %al
movq %rdi, 0x20(%rsp)
movb %al, 0x1f(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0xc4c5
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x10(%rsp)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0xc4c7
jmp 0xc4d5
jmp 0xc4c9
movq 0x10(%rsp), %rax
cmpq 0x20(%rsp), %rax
jne 0xc4a2
cmpb $0x0, 0x1f(%rsp)
jne 0xc4fd
movl 0xc(%rsp), %esi
leaq 0x28d8b(%rip), %rdi     # 0x35272
movb $0x0, %al
callq 0x1090
movq 0x31ad3(%rip), %rax     # 0x3dfc8
movq (%rax), %rdi
callq 0x1180
movl 0xc(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/graphPrinting.c
// Function: printGraph
void printGraph(struct Graph* g) {
	
	struct Graph* index = g;
	int i= 0,j;

	do {
		if (index) {
			printf("Graph %i has id %i, %i vertices, and %i edges:\n", i, index->number, index->n, index->m);
			for (j=0; j<index->n; ++j) {
				if (index->vertices[j]) {
					printf("Vertex %i has label %s and the following neighbors:\n", index->vertices[j]->number, index->vertices[j]->label);
					printVertexList(index->vertices[j]->neighborhood);
				} else {
					printf("Vertex %i is not used by the current (induced) graph\n", j);
				}
				
			}
			printf("\n");
			index = index->next;
			++i;
		} else {
			/* if index is NULL, the input pointed to a list and not to a cycle */
			break;
		}
	} while (index != g);
	fflush(stdout);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0xc628
movl 0x4(%rsp), %esi
movq 0x8(%rsp), %rax
movl 0x8(%rax), %edx
movq 0x8(%rsp), %rax
movl (%rax), %ecx
movq 0x8(%rsp), %rax
movl 0x4(%rax), %r8d
leaq 0x28d37(%rip), %rdi     # 0x35291
movb $0x0, %al
callq 0x1090
movl $0x0, (%rsp)
movl (%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl (%rcx), %eax
jge 0xc5ff
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movslq (%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0xc5de
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movslq (%rsp), %rcx
movq (%rax,%rcx,8), %rax
movl 0x18(%rax), %esi
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movslq (%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rdx
leaq 0x28d06(%rip), %rdi     # 0x352c1
movb $0x0, %al
callq 0x1090
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movslq (%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rdi
callq 0xc300
jmp 0xc5ef
movl (%rsp), %esi
leaq 0x28d0e(%rip), %rdi     # 0x352f6
movb $0x0, %al
callq 0x1090
jmp 0xc5f1
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0xc568
leaq 0x28aaf(%rip), %rdi     # 0x350b5
movb $0x0, %al
callq 0x1090
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%rsp)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0xc62a
jmp 0xc63c
jmp 0xc62c
movq 0x8(%rsp), %rax
cmpq 0x10(%rsp), %rax
jne 0xc52b
movq 0x31985(%rip), %rax     # 0x3dfc8
movq (%rax), %rdi
callq 0x1180
addq $0x18, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/graphPrinting.c
// Function: printGraphEdges
void printGraphEdges(struct Graph *g) {
	int i;
	printf("Graph has %i vertices and %i edges:\n", g->n, g->m);
	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) {
					printf("(%i, %i) %s d: (%i, %i) visited: (%i,  %i)\n", idx->startPoint->number, idx->endPoint->number, idx->label, idx->startPoint->d, idx->endPoint->d, idx->startPoint->visited, idx->endPoint->visited);
				}
			}
		}
	}
	fflush(stdout);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq 0x20(%rsp), %rax
movl (%rax), %esi
movq 0x20(%rsp), %rax
movl 0x4(%rax), %edx
leaq 0x28cbd(%rip), %rdi     # 0x3532c
movb $0x0, %al
callq 0x1090
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl (%rcx), %eax
jge 0xc773
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x1c(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0xc761
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x1c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0xc75f
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movl 0x18(%rax), %eax
cmpl 0x1c(%rsp), %eax
jle 0xc74a
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movl 0x18(%rax), %esi
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movl 0x18(%rax), %edx
movq 0x10(%rsp), %rax
movq (%rax), %rcx
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movl 0x28(%rax), %r8d
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movl 0x28(%rax), %r9d
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movl 0x1c(%rax), %r10d
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movl 0x1c(%rax), %eax
leaq 0x28c16(%rip), %rdi     # 0x35351
movl %r10d, (%rsp)
movl %eax, 0x8(%rsp)
movb $0x0, %al
callq 0x1090
jmp 0xc74c
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0xc6c3
jmp 0xc761
jmp 0xc763
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0xc67e
movq 0x3184e(%rip), %rax     # 0x3dfc8
movq (%rax), %rdi
callq 0x1180
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/graphPrinting.c
// Function: printGraphEdgesOfTwoGraphs
void printGraphEdgesOfTwoGraphs(char* name, struct Graph *g, struct Graph* h) {
	int i;
	printf("%s 1 has %i vertices and %i edges:\n", name, g->n, g->m);
	printf("%s 2 has %i vertices and %i edges:\n", name, h->n, h->m);
	for (i=0; i<g->n; ++i) {
		printf("%i: ", i);
		if (g->vertices[i]) {
			struct VertexList *idx;
			for (idx = g->vertices[i]->neighborhood; idx; idx = idx->next) {
				printf("%i ", idx->endPoint->number);	
			}
		}
		printf("\n%i: ", i);
		if (h->vertices[i]) {
			struct VertexList *idx;
			for (idx = h->vertices[i]->neighborhood; idx; idx = idx->next) {
				printf("%i ", idx->endPoint->number);	
			}
		}
		printf("\n\n");
	}
	fflush(stdout);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rax
movl (%rax), %edx
movq 0x28(%rsp), %rax
movl 0x4(%rax), %ecx
leaq 0x28b78(%rip), %rdi     # 0x35386
movb $0x0, %al
callq 0x1090
movq 0x30(%rsp), %rsi
movq 0x20(%rsp), %rax
movl (%rax), %edx
movq 0x20(%rsp), %rax
movl 0x4(%rax), %ecx
leaq 0x28b7a(%rip), %rdi     # 0x353aa
movb $0x0, %al
callq 0x1090
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movq 0x28(%rsp), %rcx
cmpl (%rcx), %eax
jge 0xc95a
movl 0x1c(%rsp), %esi
leaq 0x28b74(%rip), %rdi     # 0x353cf
movb $0x0, %al
callq 0x1090
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x1c(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0xc8c6
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x1c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0xc8c4
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movl 0x18(%rax), %esi
leaq 0x29754(%rip), %rdi     # 0x36001
movb $0x0, %al
callq 0x1090
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0xc892
jmp 0xc8c6
movl 0x1c(%rsp), %esi
leaq 0x28afd(%rip), %rdi     # 0x353ce
movb $0x0, %al
callq 0x1090
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x1c(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0xc93c
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x1c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0xc93a
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movl 0x18(%rax), %esi
leaq 0x296de(%rip), %rdi     # 0x36001
movb $0x0, %al
callq 0x1090
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0xc908
jmp 0xc93c
leaq 0x28771(%rip), %rdi     # 0x350b4
movb $0x0, %al
callq 0x1090
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0xc83f
movq 0x31667(%rip), %rax     # 0x3dfc8
movq (%rax), %rdi
callq 0x1180
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/graphPrinting.c
// Function: printDirectedGraphDotFormat
void printDirectedGraphDotFormat(struct Graph* g, FILE* out) {
	fprintf(out, "digraph %i {\n", g->number);
	for (int v=0; v<g->n; ++v) {
		fprintf(out, "%i [label=%s];\n", v, g->vertices[v]->label);
	}
	for (int v=0; v<g->n; ++v) {
		for (struct VertexList* e=g->vertices[v]->neighborhood; e!=NULL; e=e->next) {
			fprintf(out, "%i -> %i [label=%s];\n", e->startPoint->number, e->endPoint->number, g->vertices[v]->label);
		}
	}
	fprintf(out, "}\n");
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rax
movl 0x8(%rax), %edx
leaq 0x286e4(%rip), %rsi     # 0x353f6
movb $0x0, %al
callq 0x1140
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl (%rcx), %eax
jge 0xcd67
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %edx
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rcx
leaq 0x286d0(%rip), %rsi     # 0x35423
movb $0x0, %al
callq 0x1140
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0xcd21
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl (%rcx), %eax
jge 0xce05
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0xcdf3
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movl 0x18(%rax), %edx
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movl 0x18(%rax), %ecx
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x10(%rsp), %rsi
movq (%rax,%rsi,8), %rax
movq (%rax), %r8
leaq 0x28628(%rip), %rsi     # 0x35404
movb $0x0, %al
callq 0x1140
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0xcd9b
jmp 0xcdf5
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0xcd6f
movq 0x18(%rsp), %rdi
leaq 0x28609(%rip), %rsi     # 0x3541a
movb $0x0, %al
callq 0x1140
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/graphPrinting.c
// Function: printGraphDotFormat
void printGraphDotFormat(struct Graph* g, FILE* out) {
	fprintf(out, "graph %i {\n", g->number);
	for (int v=0; v<g->n; ++v) {
		fprintf(out, "%i [label=%s];\n", v, g->vertices[v]->label);
	}
	for (int v=0; v<g->n; ++v) {
		for (struct VertexList* e=g->vertices[v]->neighborhood; e!=NULL; e=e->next) {
			if (e->startPoint->number < e->endPoint->number) {
				fprintf(out, "%i -- %i [label=%s];\n", e->startPoint->number, e->endPoint->number, g->vertices[v]->label);
			}
		}
	}
	fprintf(out, "}\n");
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rax
movl 0x8(%rax), %edx
leaq 0x285b6(%rip), %rsi     # 0x353f8
movb $0x0, %al
callq 0x1140
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl (%rcx), %eax
jge 0xce97
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %edx
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rcx
leaq 0x285a0(%rip), %rsi     # 0x35423
movb $0x0, %al
callq 0x1140
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0xce51
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl (%rcx), %eax
jge 0xcf51
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0xcf3f
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movl 0x18(%rax), %eax
movq 0x8(%rsp), %rcx
movq 0x18(%rcx), %rcx
cmpl 0x18(%rcx), %eax
jge 0xcf2d
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movl 0x18(%rax), %edx
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movl 0x18(%rax), %ecx
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x10(%rsp), %rsi
movq (%rax,%rsi,8), %rax
movq (%rax), %r8
leaq 0x284f7(%rip), %rsi     # 0x3541d
movb $0x0, %al
callq 0x1140
jmp 0xcf2f
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0xcecb
jmp 0xcf41
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0xce9f
movq 0x18(%rsp), %rdi
leaq 0x284bd(%rip), %rsi     # 0x3541a
movb $0x0, %al
callq 0x1140
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/hp_cactus.c
// Function: visit
static int visit(struct Vertex* v, const int* criticality) {
	if (!(v->visited)) {
		v->visited = 1;
		if (criticality[v->number] > 1) {
			return 1;
		}
	}
	return 0;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq -0x10(%rsp), %rax
cmpl $0x0, 0x1c(%rax)
jne 0xd211
movq -0x10(%rsp), %rax
movl $0x1, 0x1c(%rax)
movq -0x18(%rsp), %rax
movq -0x10(%rsp), %rcx
movslq 0x18(%rcx), %rcx
cmpl $0x1, (%rax,%rcx,4)
jle 0xd20f
movl $0x1, -0x4(%rsp)
jmp 0xd219
jmp 0xd211
movl $0x0, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/importantSubtrees.c
// Function: graph2ComponentCleanup
void graph2ComponentCleanup(struct Graph* g, struct Graph* components, struct GraphPool* gp) {
	for (struct Graph* c=components; c!=NULL; c=c->next) {
		for (int v=0; v<c->n; ++v) {
			c->vertices[v] = NULL;
		}
		c->n = 0;
	}
	dumpGraphList(gp, components);
	for (int v=0; v<g->n; ++v) {
		g->vertices[v]->number = v;
	}
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0xd7c8
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl (%rcx), %eax
jge 0xd7ad
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x4(%rsp), %rcx
movq $0x0, (%rax,%rcx,8)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0xd77d
movq 0x8(%rsp), %rax
movl $0x0, (%rax)
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0xd76d
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x1fc60
movl $0x0, (%rsp)
movl (%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl (%rcx), %eax
jge 0xd80c
movl (%rsp), %ecx
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movslq (%rsp), %rdx
movq (%rax,%rdx,8), %rax
movl %ecx, 0x18(%rax)
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0xd7de
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/importantSubtrees.c
// Function: importanceCount
int importanceCount(struct Graph* g, struct Graph* h, struct GraphPool* gp) {
	struct Graph* components = graph2Components(g, gp);
	int freq = 0;
	for (struct Graph* component=components; component!=NULL; component=component->next) {
		if (isSubtree(component, h, gp)) {
			++freq;
		}
	}
	graph2ComponentCleanup(g, components, gp);
	return freq;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xd480
movq %rax, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0xd896
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0xfbd0
cmpb $0x0, %al
je 0xd884
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0xd886
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0xd859
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0xd750
movl 0x14(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/importantSubtrees.c
// Function: importanceRelative
double importanceRelative(struct Graph* g, struct Graph* h, struct GraphPool* gp) {
	struct Graph* components = graph2Components(g, gp);
	int freq = 0;
	int count = 0;
	for (struct Graph* component=components; component!=NULL; component=component->next) {
		if (isSubtree(component, h, gp)) {
			++freq;
		}
		++count;
	}
	graph2ComponentCleanup(g, components, gp);
	return ((double)freq) / ((double)count);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xd480
movq %rax, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl $0x0, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0xd947
movq 0x8(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0xfbd0
cmpb $0x0, %al
je 0xd92c
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0xd901
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0xd750
cvtsi2sdl 0x14(%rsp), %xmm0
cvtsi2sdl 0x10(%rsp), %xmm1
divsd %xmm1, %xmm0
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/intMath.c
// Function: mod
int mod(int a, int b) {
	if (a % b >= 0) {
		return a % b;
	} else {
		return b + (a % b);
	}
}

// Assembly:
movl %edi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movl -0x8(%rsp), %eax
cltd
idivl -0xc(%rsp)
cmpl $0x0, %edx
jl 0xda95
movl -0x8(%rsp), %eax
cltd
idivl -0xc(%rsp)
movl %edx, -0x4(%rsp)
jmp 0xdab0
movl -0xc(%rsp), %eax
movl %eax, -0x10(%rsp)
movl -0x8(%rsp), %eax
cltd
idivl -0xc(%rsp)
movl -0x10(%rsp), %eax
addl %edx, %eax
movl %eax, -0x4(%rsp)
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/intMath.c
// Function: ipow
int ipow(int b, int e){
    //negative sucks just treat it as zero.
    int r;
    if(e<=0) return 1;
    if(e%2==0){
        r=ipow(b,e/2);
        return r*r;
    }
    return b*ipow(b,e-1);
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jg 0xdadd
movl $0x1, 0x14(%rsp)
jmp 0xdb3d
movl 0xc(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0x0, %edx
jne 0xdb18
movl 0x10(%rsp), %edi
movl 0xc(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %esi
callq 0xdac0
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
imull 0x8(%rsp), %eax
movl %eax, 0x14(%rsp)
jmp 0xdb3d
movl 0x10(%rsp), %eax
movl %eax, 0x4(%rsp)
movl 0x10(%rsp), %edi
movl 0xc(%rsp), %esi
subl $0x1, %esi
callq 0xdac0
movl %eax, %ecx
movl 0x4(%rsp), %eax
imull %ecx, %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/intSet.c
// Function: getIntElement
struct IntElement* getIntElement() {
	struct IntElement* e = malloc(sizeof(struct IntElement));
	e->value = 0;
	e->next = NULL;
	return e;
}

// Assembly:
pushq %rax
movl $0x10, %edi
callq 0x1170
movq %rax, (%rsp)
movq (%rsp), %rax
movl $0x0, (%rax)
movq (%rsp), %rax
movq $0x0, 0x8(%rax)
movq (%rsp), %rax
popq %rcx
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/intSet.c
// Function: getIntSet
struct IntSet* getIntSet() {
	struct IntSet* s = malloc(sizeof(struct IntSet));
	s->first = NULL;
	s->last = NULL;
	s->size = 0;
	return s;
}

// Assembly:
pushq %rax
movl $0x20, %edi
callq 0x1170
movq %rax, (%rsp)
movq (%rsp), %rax
movq $0x0, (%rax)
movq (%rsp), %rax
movq $0x0, 0x8(%rax)
movq (%rsp), %rax
movq $0x0, 0x18(%rax)
movq (%rsp), %rax
popq %rcx
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/intSet.c
// Function: printIntSet
void printIntSet(struct IntSet* s, FILE*out) {
	fprintf(out, "%zu elements: [", s->size);
	for (struct IntElement* i=s->first; i!=NULL; i=i->next) {
		fprintf(out, "%i, ", i->value);
	}
	fprintf(out, "]\n");
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdx
leaq 0x27720(%rip), %rsi     # 0x35433
movb $0x0, %al
callq 0x1140
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0xdd54
movq 0x8(%rsp), %rdi
movq (%rsp), %rax
movl (%rax), %edx
leaq 0x27704(%rip), %rsi     # 0x35443
movb $0x0, %al
callq 0x1140
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
jmp 0xdd26
movq 0x8(%rsp), %rdi
leaq 0x28a87(%rip), %rsi     # 0x367e7
movb $0x0, %al
callq 0x1140
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/intSet.c
// Function: printIntSetAsLibSvm
void printIntSetAsLibSvm(struct IntSet* s, int label, FILE* out) {
	fprintf(out, "%i", label);
	for (struct IntElement* i=s->first; i!=NULL; i=i->next) {
		fprintf(out, " %i:1", i->value);
	}
	fprintf(out, "\n");
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movl 0x1c(%rsp), %edx
leaq 0x28802(%rip), %rsi     # 0x365f4
movb $0x0, %al
callq 0x1140
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0xde38
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rax
movl (%rax), %edx
leaq 0x27627(%rip), %rsi     # 0x35448
movb $0x0, %al
callq 0x1140
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0xde06
movq 0x10(%rsp), %rdi
leaq 0x27271(%rip), %rsi     # 0x350b5
movb $0x0, %al
callq 0x1140
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/intSet.c
// Function: containsInt
char containsInt(struct IntSet* s, int i) {
	for (struct IntElement* e=s->first; e!=NULL; e=e->next) {
		if (e->value == i) {
			return 1;
		}
	}
	return 0;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movl %esi, -0x14(%rsp)
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x20(%rsp)
cmpq $0x0, -0x20(%rsp)
je 0xdf04
movq -0x20(%rsp), %rax
movl (%rax), %eax
cmpl -0x14(%rsp), %eax
jne 0xdef2
movb $0x1, -0x1(%rsp)
jmp 0xdf09
jmp 0xdef4
movq -0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x20(%rsp)
jmp 0xded6
movb $0x0, -0x1(%rsp)
movb -0x1(%rsp), %al
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/intSet.c
// Function: appendInt
void appendInt(struct IntSet* s, int i) {
	struct IntElement* e = getIntElement();
	e->value = i;
	if (s->last != NULL) {
		s->last->next = e;
		s->last = e; 
	} else {
		s->first = s->last = e;
	}
	s->size += 1;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
callq 0xdc50
movq %rax, (%rsp)
movl 0xc(%rsp), %ecx
movq (%rsp), %rax
movl %ecx, (%rax)
movq 0x10(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0xdf5c
movq (%rsp), %rcx
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x8(%rax)
movq (%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
jmp 0xdf71
movq (%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/intSet.c
// Function: addIntSortedWithDuplicates
void addIntSortedWithDuplicates(struct IntSet* s, int i) {
	struct IntElement* newElement = getIntElement();
	newElement->value = i;
	if (s->last != NULL) {
		if (s->last->value <= i) {
			s->last->next = newElement;
			s->last = newElement;
		} else {
			if (s->first->value > i) {
				newElement->next = s->first;
				s->first = newElement;
			} else {
				for (struct IntElement* e=s->first; e!=NULL; e=e->next) {
					if (e->next->value > i) {
						newElement->next = e->next;
						e->next = newElement;
						break;
					}
				}
			}
		}
	} else {
		s->first = s->last = newElement;
	}
	s->size += 1;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movl %esi, 0x1c(%rsp)
callq 0xdc50
movq %rax, 0x10(%rsp)
movl 0x1c(%rsp), %ecx
movq 0x10(%rsp), %rax
movl %ecx, (%rax)
movq 0x20(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0xe088
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movl (%rax), %eax
cmpl 0x1c(%rsp), %eax
jg 0xdff8
movq 0x10(%rsp), %rcx
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
jmp 0xe086
movq 0x20(%rsp), %rax
movq (%rax), %rax
movl (%rax), %eax
cmpl 0x1c(%rsp), %eax
jle 0xe028
movq 0x20(%rsp), %rax
movq (%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
jmp 0xe084
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0xe082
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movl (%rax), %eax
cmpl 0x1c(%rsp), %eax
jle 0xe070
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
jmp 0xe082
jmp 0xe072
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0xe035
jmp 0xe084
jmp 0xe086
jmp 0xe09e
movq 0x10(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/intSet.c
// Function: appendIntElement
void appendIntElement(struct IntSet* s, struct IntElement* e) {
	if (s->last != NULL) {
		s->last->next = e;
		s->last = e; 
	} else {
		s->first = s->last = e;
	}
	s->size += 1;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x8(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0xe308
movq -0x10(%rsp), %rcx
movq -0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x8(%rax)
movq -0x10(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
jmp 0xe31e
movq -0x10(%rsp), %rcx
movq -0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq -0x8(%rsp), %rax
movq %rcx, (%rax)
movq -0x8(%rsp), %rax
movq 0x18(%rax), %rcx
addq $0x1, %rcx
movq %rcx, 0x18(%rax)
retq
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/intSet.c
// Function: popIntElement
struct IntElement* popIntElement(struct IntSet* s) {
	struct IntElement* e = s->first;
	if (e != NULL) { 
		s->first = e->next;
		if (e->next == NULL) {
			s->last = NULL;
		}
		s->size -= 1;
		e->next = NULL;
	}
	return e;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x10(%rsp)
cmpq $0x0, -0x10(%rsp)
je 0xe392
movq -0x10(%rsp), %rax
movq 0x8(%rax), %rcx
movq -0x8(%rsp), %rax
movq %rcx, (%rax)
movq -0x10(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0xe374
movq -0x8(%rsp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rsp), %rax
movq 0x18(%rax), %rcx
subq $0x1, %rcx
movq %rcx, 0x18(%rax)
movq -0x10(%rsp), %rax
movq $0x0, 0x8(%rax)
movq -0x10(%rsp), %rax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/intSet.c
// Function: intersectIntSet
struct IntSet* intersectIntSet(const struct IntSet* setA, const struct IntSet* setB) {
  struct IntSet* intersection = getIntSet();
  struct IntElement* a = setA->first;
  struct IntElement* b = setB->first;
 
  /* Once one or the other list runs out -- we're done */
  while (a != NULL && b != NULL)
  {
    if (a->value == b->value)
    {
       appendInt(intersection, a->value);
       a = a->next;
       b = b->next;
    }
    else if (a->value < b->value) /* advance the smaller list */      
       a = a->next;
    else
       b = b->next;
  }
  return intersection;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
callq 0xdc80
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
xorl %eax, %eax
cmpq $0x0, 0x18(%rsp)
movb %al, 0xf(%rsp)
je 0xe3ed
cmpq $0x0, 0x10(%rsp)
setne %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0xe3f7
jmp 0xe46b
movq 0x18(%rsp), %rax
movl (%rax), %eax
movq 0x10(%rsp), %rcx
cmpl (%rcx), %eax
jne 0xe436
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rax
movl (%rax), %esi
callq 0xdf10
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0xe466
movq 0x18(%rsp), %rax
movl (%rax), %eax
movq 0x10(%rsp), %rcx
cmpl (%rcx), %eax
jge 0xe456
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
jmp 0xe464
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0xe466
jmp 0xe3d2
movq 0x20(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/intSet.c
// Function: isSortedIntSet
char isSortedIntSet(struct IntSet* s) {
	if (s->size < 2) {
		return 1;
	}
	for (struct IntElement* e=s->first; e->next!=NULL; e=e->next) {
		if (e->value > e->next->value) {
			return 0;
		}
	}
	return 1;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq -0x10(%rsp), %rax
cmpq $0x2, 0x18(%rax)
jae 0xe498
movb $0x1, -0x1(%rsp)
jmp 0xe4e3
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rsp)
movq -0x18(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0xe4de
movq -0x18(%rsp), %rax
movl (%rax), %eax
movq -0x18(%rsp), %rcx
movq 0x8(%rcx), %rcx
cmpl (%rcx), %eax
jle 0xe4cc
movb $0x0, -0x1(%rsp)
jmp 0xe4e3
jmp 0xe4ce
movq -0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rsp)
jmp 0xe4a5
movb $0x1, -0x1(%rsp)
movb -0x1(%rsp), %al
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/intSet.c
// Function: isSortedUniqueIntSet
char isSortedUniqueIntSet(struct IntSet* s) {
	if (s->size < 2) {
		return 1;
	}
	for (struct IntElement* e=s->first; e->next!=NULL; e=e->next) {
		if (e->value >= e->next->value) {
			return 0;
		}
	}
	return 1;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq -0x10(%rsp), %rax
cmpq $0x2, 0x18(%rax)
jae 0xe508
movb $0x1, -0x1(%rsp)
jmp 0xe553
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rsp)
movq -0x18(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0xe54e
movq -0x18(%rsp), %rax
movl (%rax), %eax
movq -0x18(%rsp), %rcx
movq 0x8(%rcx), %rcx
cmpl (%rcx), %eax
jl 0xe53c
movb $0x0, -0x1(%rsp)
jmp 0xe553
jmp 0xe53e
movq -0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x18(%rsp)
jmp 0xe515
movb $0x1, -0x1(%rsp)
movb -0x1(%rsp), %al
retq
nopl (%rax,%rax)