LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/memoryManagement.c
// Function: freeGraphPool
void freeGraphPool(struct GraphPool *p) {
	while (p->unused) {
		p->tmp = p->unused->next;
		if ((p->unused < p->poolPointer) || (p->unused > &(p->poolPointer[p->initNumberOfElements-1]))) {
			free(p->unused);
		}
		p->unused = p->tmp;
	}
	if (!MEM_DEBUG) {
		free(p->poolPointer);
	}
	free(p);
}

// Assembly:
pushq %rax
movq %rdi, (%rsp)
movq (%rsp), %rax
cmpq $0x0, (%rax)
je 0x1fa27
movq (%rsp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq (%rsp), %rax
movq (%rax), %rax
movq (%rsp), %rcx
cmpq 0x28(%rcx), %rax
jb 0x1fa0a
movq (%rsp), %rax
movq (%rax), %rax
movq (%rsp), %rcx
movq 0x28(%rcx), %rcx
movq (%rsp), %rdx
movl 0x20(%rdx), %edx
subl $0x1, %edx
movl %edx, %edx
shlq $0x5, %rdx
addq %rdx, %rcx
cmpq %rcx, %rax
jbe 0x1fa16
movq (%rsp), %rax
movq (%rax), %rdi
callq 0x1030
movq (%rsp), %rax
movq 0x8(%rax), %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
jmp 0x1f9b5
movq (%rsp), %rax
movq 0x28(%rax), %rdi
callq 0x1030
movq (%rsp), %rdi
callq 0x1030
popq %rax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/memoryManagement.c
// Function: getGraph
struct Graph* getGraph(struct GraphPool* p) {
	if (p->unused) {
		/* get first of the unused elements */
		p->tmp = p->unused;
		p->unused = p->tmp->next;
	} else {
		/* allocate memory for new struct */
		if (!(p->tmp = malloc(sizeof(struct Graph)))) {
			/* malloc did not work */
			printf("Error allocating memory\n");
			return NULL;
		} 
	}
	
	/* malloc worked or there was an unused element left, initialize stuff */
	wipeGraph(p->tmp);
	
	return p->tmp;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq $0x0, (%rax)
je 0x1fa7c
movq 0x8(%rsp), %rax
movq (%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
jmp 0x1fab0
movl $0x20, %edi
callq 0x1170
movq 0x8(%rsp), %rcx
movq %rax, 0x8(%rcx)
cmpq $0x0, %rax
jne 0x1faae
leaq 0x160a4(%rip), %rdi     # 0x35b40
movb $0x0, %al
callq 0x1090
movq $0x0, 0x10(%rsp)
jmp 0x1facc
jmp 0x1fab0
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x1fae0
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/memoryManagement.c
// Function: wipeGraph
void wipeGraph(struct Graph* g) {
	g->n = 0;
	g->m = 0;
	g->number = 0;
	g->activity = 0;
	g->vertices = NULL;
	g->next = NULL;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movl $0x0, (%rax)
movq -0x8(%rsp), %rax
movl $0x0, 0x4(%rax)
movq -0x8(%rsp), %rax
movl $0x0, 0x8(%rax)
movq -0x8(%rsp), %rax
movl $0x0, 0xc(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x10(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x18(%rax)
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/memoryManagement.c
// Function: dumpGraph
void dumpGraph(struct GraphPool* p, struct Graph *g) {
	struct VertexList *tmp;
	int i;
	/* dump content */
	if (g->vertices) {
		for (i=0; i<g->n; ++i) {
			if (g->vertices[i]) {
				while (g->vertices[i]->neighborhood) {
					tmp = g->vertices[i]->neighborhood->next;
					dumpVertexList(p->listPool, g->vertices[i]->neighborhood);
					g->vertices[i]->neighborhood = tmp;
				}
				dumpVertex(p->vertexPool, g->vertices[i]);
			}
		}
	
		free(g->vertices);
	}
	
	if (MEM_DEBUG) {
		free(g);
	} else {
		/* append g to the unused list */
		g->next = p->unused;
		p->unused = g;
	}
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rax
cmpq $0x0, 0x10(%rax)
je 0x1fc3b
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x18(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x1fc2d
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0xc(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x1fc1b
jmp 0x1fb82
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rax
cmpq $0x0, 0x8(%rax)
je 0x1fbfb
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rsi
callq 0x1f410
movq 0x10(%rsp), %rcx
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0xc(%rsp), %rdx
movq (%rax,%rdx,8), %rax
movq %rcx, 0x8(%rax)
jmp 0x1fb82
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x1f810
jmp 0x1fc1d
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x1fb56
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x1030
movq 0x20(%rsp), %rax
movq (%rax), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/memoryManagement.c
// Function: createShallowGraphPool
struct ShallowGraphPool* createShallowGraphPool(unsigned int initNumberOfElements, struct ListPool* lp){
	struct ShallowGraphPool* newPool;
	
	if (MEM_DEBUG) {
		// this allows the dump methods to free everything that is dumped
		initNumberOfElements = 1;
	}

	if ((newPool = malloc(sizeof(struct ShallowGraphPool)))) {
		/* set the listpool of the graphpool according to the input. good for dumping actions */
		newPool->listPool = lp;
		if ((newPool->unused = malloc(initNumberOfElements * sizeof(struct ShallowGraph)))) {
			unsigned int i;
			/* we have allocated an array, but need a list, thus set ponters accordingly */
			for (i=0; i<initNumberOfElements-1; ++i) {
				(newPool->unused[i]).next = &(newPool->unused[i+1]);
			}
			(newPool->unused[initNumberOfElements-1]).next = NULL;
			newPool->poolPointer = newPool->unused;
			newPool->initNumberOfElements = initNumberOfElements;
		} else {
			printf("Error while initializing object pool for list elements\n");
			return NULL;
		}
	} else {
		printf("Error while initializing object pool for list elements\n");
		return NULL;
	}
	
	return newPool;
}

// Assembly:
subq $0x28, %rsp
movl %edi, 0x1c(%rsp)
movq %rsi, 0x10(%rsp)
movl $0x28, %edi
callq 0x1170
movq %rax, 0x8(%rsp)
cmpq $0x0, %rax
je 0x1fdb0
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movl 0x1c(%rsp), %eax
imulq $0x30, %rax, %rdi
callq 0x1170
movq 0x8(%rsp), %rcx
movq %rax, (%rcx)
cmpq $0x0, %rax
je 0x1fd95
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
movl 0x1c(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jae 0x1fd56
movq 0x8(%rsp), %rax
movq (%rax), %rcx
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, %eax
imulq $0x30, %rax, %rax
addq %rax, %rcx
movq 0x8(%rsp), %rax
movq (%rax), %rax
movl 0x4(%rsp), %edx
imulq $0x30, %rdx, %rdx
addq %rdx, %rax
movq %rcx, 0x18(%rax)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x1fd0b
movq 0x8(%rsp), %rax
movq (%rax), %rax
movl 0x1c(%rsp), %ecx
subl $0x1, %ecx
movl %ecx, %ecx
imulq $0x30, %rcx, %rcx
addq %rcx, %rax
movq $0x0, 0x18(%rax)
movq 0x8(%rsp), %rax
movq (%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x20(%rax)
movl 0x1c(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0x18(%rax)
jmp 0x1fdae
leaq 0x15d6c(%rip), %rdi     # 0x35b08
movb $0x0, %al
callq 0x1090
movq $0x0, 0x20(%rsp)
jmp 0x1fdd3
jmp 0x1fdc9
leaq 0x15d51(%rip), %rdi     # 0x35b08
movb $0x0, %al
callq 0x1090
movq $0x0, 0x20(%rsp)
jmp 0x1fdd3
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/memoryManagement.c
// Function: freeShallowGraphPool
void freeShallowGraphPool(struct ShallowGraphPool *p) {
	while (p->unused) {
		p->tmp = p->unused->next;
		if ((p->unused < p->poolPointer) || (p->unused > &(p->poolPointer[p->initNumberOfElements-1]))) {
			free(p->unused);
		}
		p->unused = p->tmp;
	}
	if (!MEM_DEBUG) {
		free(p->poolPointer);
	}
	free(p);
}

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

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq $0x0, (%rax)
je 0x1feac
movq 0x8(%rsp), %rax
movq (%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
jmp 0x1fee0
movl $0x30, %edi
callq 0x1170
movq 0x8(%rsp), %rcx
movq %rax, 0x8(%rcx)
cmpq $0x0, %rax
jne 0x1fede
leaq 0x15c74(%rip), %rdi     # 0x35b40
movb $0x0, %al
callq 0x1090
movq $0x0, 0x10(%rsp)
jmp 0x1fefc
jmp 0x1fee0
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x1ff10
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/memoryManagement.c
// Function: wipeShallowGraph
void wipeShallowGraph(struct ShallowGraph* g) {
	g->next = NULL;
	g->prev = NULL;
	g->m = 0;
	g->edges = NULL;
	g->lastEdge = NULL;
	g->data = 0;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq -0x8(%rsp), %rax
movq $0x0, 0x18(%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x20(%rax)
movq -0x8(%rsp), %rax
movl $0x0, 0x10(%rax)
movq -0x8(%rsp), %rax
movq $0x0, (%rax)
movq -0x8(%rsp), %rax
movq $0x0, 0x8(%rax)
movq -0x8(%rsp), %rax
movl $0x0, 0x28(%rax)
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/memoryManagement.c
// Function: dumpShallowGraph
void dumpShallowGraph(struct ShallowGraphPool *p, struct ShallowGraph* g) {

	/* dump edges */
	while (g->edges) {
		p->listPool->tmp = g->edges;
		g->edges = g->edges->next;
		dumpVertexList(p->listPool, p->listPool->tmp);
	}

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

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq $0x0, (%rax)
je 0x1ffcf
movq 0x8(%rsp), %rax
movq (%rax), %rcx
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x8(%rax), %rsi
callq 0x1f410
jmp 0x1ff7e
movq 0x10(%rsp), %rax
movq (%rax), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/memoryManagement.c
// Function: dumpShallowGraphCycle
void dumpShallowGraphCycle(struct ShallowGraphPool *p, struct ShallowGraph* g) {
	struct ShallowGraph *idx = g, *tmp;
	/* to cope with the possibility that g points to a list and not to a cycle, lazy check for NULL */
	while (idx && (idx->next != g)){
		tmp = idx;
		idx = idx->next;
		dumpShallowGraph(p, tmp);
	}
	/* if g did point to a cycle of length 1 */
	if (idx) {
		dumpShallowGraph(p, idx);
	}

}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
xorl %eax, %eax
cmpq $0x0, 0x10(%rsp)
movb %al, 0x7(%rsp)
je 0x2003b
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
cmpq 0x18(%rsp), %rax
setne %al
movb %al, 0x7(%rsp)
movb 0x7(%rsp), %al
testb $0x1, %al
jne 0x20045
jmp 0x2006e
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x1ff70
jmp 0x20018
cmpq $0x0, 0x10(%rsp)
je 0x20085
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x1ff70
addq $0x28, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/memoryManagement.c
// Function: copyString
char* copyString(char* string) {
	int i;
	char* copy;

	for (i=0; string[i] != 0; ++i);

	copy = malloc((i + 1) * sizeof(char));

	for (i=0; string[i] != 0; ++i) {
		copy[i] = string[i];
	}
	copy[i] = 0;

	return copy;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x200c3
jmp 0x200b6
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x200a1
movl 0xc(%rsp), %eax
addl $0x1, %eax
movslq %eax, %rdi
shlq $0x0, %rdi
callq 0x1170
movq %rax, (%rsp)
movl $0x0, 0xc(%rsp)
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
movsbl (%rax,%rcx), %eax
cmpl $0x0, %eax
je 0x2011b
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
movb (%rax,%rcx), %dl
movq (%rsp), %rax
movslq 0xc(%rsp), %rcx
movb %dl, (%rax,%rcx)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x200e2
movq (%rsp), %rax
movslq 0xc(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movq (%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/minhashing.c
// Function: getRandomPermutation
int* getRandomPermutation(int n) {
	int* permutation = malloc(n * sizeof(int));
	if (permutation) {
		for (int i=0; i<n; ++i) {
			permutation[i] = i+1;
		}
		shuffleArray(permutation, n);
	} else {
		fprintf(stderr, "Error allocating memory for permutation\n");
	}
	return permutation;
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movslq 0x14(%rsp), %rdi
shlq $0x2, %rdi
callq 0x1170
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x201a6
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0x14(%rsp), %eax
jge 0x20196
movl 0x4(%rsp), %edx
addl $0x1, %edx
movq 0x8(%rsp), %rax
movslq 0x4(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x2016b
movq 0x8(%rsp), %rdi
movl 0x14(%rsp), %esi
callq 0x201d0
jmp 0x201be
movq 0x1de4b(%rip), %rax     # 0x3dff8
movq (%rax), %rdi
leaq 0x159a2(%rip), %rsi     # 0x35b59
movb $0x0, %al
callq 0x1140
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/minhashing.c
// Function: shuffleArray
static void shuffleArray(int* array, int arraySize) {
	for (int i = arraySize - 1; i > 0; i--)
	{
		int index = rand() % (i + 1);
		// Simple swap
		int a = array[index];
		array[index] = array[i];
		array[i] = a;
	}
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl 0xc(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x8(%rsp)
cmpl $0x0, 0x8(%rsp)
jle 0x20249
callq 0x1220
movl 0x8(%rsp), %ecx
addl $0x1, %ecx
cltd
idivl %ecx
movl %edx, 0x4(%rsp)
movq 0x10(%rsp), %rax
movslq 0x4(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, (%rsp)
movq 0x10(%rsp), %rax
movslq 0x8(%rsp), %rcx
movl (%rax,%rcx,4), %edx
movq 0x10(%rsp), %rax
movslq 0x4(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movl (%rsp), %edx
movq 0x10(%rsp), %rax
movslq 0x8(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movl 0x8(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x201e8
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/minhashing.c
// Function: posetPermutationMark
int posetPermutationMark(int* permutation, size_t n, struct Graph* F) {
	for (int v=0; v<F->n; ++v) {
		F->vertices[v]->visited = 0;
	}
	size_t shrunkSize = 0;
	for (size_t i=0; i<n; ++i) {
		struct Vertex* v = F->vertices[permutation[i]];
		if (v->visited == 0) {
			markConnectedComponent(v, 1);
			++shrunkSize;
		} else {
			permutation[i] = -1;
		}
	}
	return shrunkSize;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x2029e
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x1c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movl $0x0, 0x1c(%rax)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x2026b
movq $0x0, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x28(%rsp), %rax
jae 0x20326
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x30(%rsp), %rcx
movq 0x8(%rsp), %rdx
movslq (%rcx,%rdx,4), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, (%rsp)
movq (%rsp), %rax
cmpl $0x0, 0x1c(%rax)
jne 0x20303
movq (%rsp), %rdi
movl $0x1, %esi
callq 0x112d0
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x20314
movq 0x30(%rsp), %rax
movq 0x8(%rsp), %rcx
movl $0xffffffff, (%rax,%rcx,4) # imm = 0xFFFFFFFF
jmp 0x20316
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x202b0
movq 0x10(%rsp), %rax
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/minhashing.c
// Function: posetPermutationShrink
int* posetPermutationShrink(int* permutation, size_t n, size_t shrunkSize) {
	int* condensedSequence = malloc(shrunkSize * sizeof(int));
	size_t posInCondensed = 0;
	for (size_t i=0; i<n; ++i) {
		if (permutation[i] != -1) {
			condensedSequence[posInCondensed] = permutation[i];
			++posInCondensed;
		}
	}
	free(permutation);
	return condensedSequence;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x20(%rsp), %rdi
shlq $0x2, %rdi
callq 0x1170
movq %rax, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x28(%rsp), %rax
jae 0x203be
movq 0x30(%rsp), %rax
movq 0x8(%rsp), %rcx
cmpl $-0x1, (%rax,%rcx,4)
je 0x203ac
movq 0x30(%rsp), %rax
movq 0x8(%rsp), %rcx
movl (%rax,%rcx,4), %edx
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x203ae
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x20368
movq 0x30(%rsp), %rdi
callq 0x1030
movq 0x18(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/minhashing.c
// Function: posPairSorter
int posPairSorter(const void* a, const void* b, void* context) {
	struct PosPair one = *(struct PosPair*)a;
	struct PosPair two = *(struct PosPair*)b;
	struct EvaluationPlan p = *(struct EvaluationPlan*)context;

	int oneID = p.shrunkPermutations[one.permutation][one.level];
	int twoID = p.shrunkPermutations[two.permutation][two.level];

	return oneID - twoID;
}

// Assembly:
subq $0x78, %rsp
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq 0x70(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x50(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x58(%rsp)
movq 0x68(%rsp), %rax
movq (%rax), %rcx
movq %rcx, 0x40(%rsp)
movq 0x8(%rax), %rax
movq %rax, 0x48(%rsp)
movq 0x60(%rsp), %rsi
leaq 0x10(%rsp), %rdi
movl $0x30, %edx
callq 0x1150
movq 0x28(%rsp), %rax
movq 0x58(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x50(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0xc(%rsp)
movq 0x28(%rsp), %rax
movq 0x48(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x40(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0x8(%rsp)
movl 0xc(%rsp), %eax
subl 0x8(%rsp), %eax
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/minhashing.c
// Function: reverseGraph
struct Graph* reverseGraph(struct Graph* g, struct GraphPool* gp) {
	struct Graph* reverse = emptyGraph(g, gp);
	for (int v=0; v<g->n; ++v) {
		for (struct VertexList* e=g->vertices[v]->neighborhood; e!=NULL; e=e->next) {
			struct VertexList* f = shallowCopyEdge(e, gp->listPool);
			f->startPoint = reverse->vertices[e->endPoint->number];
			f->endPoint = reverse->vertices[e->startPoint->number];
			addEdge(f->startPoint, f);
		}
	}
	reverse->m = g->m;
	return reverse;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0xb7c0
movq %rax, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movq 0x30(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x20578
movq 0x30(%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 0x20566
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rsi
callq 0xa310
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rsp), %rcx
movq 0x18(%rcx), %rcx
movslq 0x18(%rcx), %rcx
movq (%rax,%rcx,8), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rsp), %rcx
movq 0x10(%rcx), %rcx
movslq 0x18(%rcx), %rcx
movq (%rax,%rcx,8), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0xa660
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x204d6
jmp 0x20568
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x204aa
movq 0x30(%rsp), %rax
movl 0x4(%rax), %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x4(%rax)
movq 0x20(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/minhashing.c
// Function: dumpEvaluationPlan
struct EvaluationPlan dumpEvaluationPlan(struct EvaluationPlan p, struct GraphPool* gp) {
	free(p.order);
	for (size_t i=0; i<p.sketchSize; ++i) {
		free(p.shrunkPermutations[i]);
	}
	free(p.shrunkPermutations);
	for (int v=1; v<p.poset->n; ++v) { // start from 1, as empty pattern has no graph attached
		dumpGraph(gp, (struct Graph*)(p.poset->vertices[v]->label));
		p.poset->vertices[v]->label = NULL;
	}
	dumpGraph(gp, p.reversePoset);
	dumpGraph(gp, p.poset);
	struct EvaluationPlan empty = {0};
	return empty;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x8(%rsp)
movq %rdi, 0x10(%rsp)
leaq 0x40(%rsp), %rax
movq %rax, 0x18(%rsp)
movq %rsi, 0x30(%rsp)
movq 0x10(%rax), %rdi
callq 0x1030
movq $0x0, 0x28(%rsp)
movq 0x18(%rsp), %rcx
movq 0x28(%rsp), %rax
cmpq 0x28(%rcx), %rax
jae 0x20856
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x28(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1030
movq 0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x28(%rsp)
jmp 0x2081f
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x1030
movl $0x1, 0x24(%rsp)
movq 0x18(%rsp), %rcx
movl 0x24(%rsp), %eax
movq (%rcx), %rcx
cmpl (%rcx), %eax
jge 0x208c7
movq 0x18(%rsp), %rax
movq 0x30(%rsp), %rdi
movq (%rax), %rax
movq 0x10(%rax), %rax
movslq 0x24(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rsi
callq 0x1fb30
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movslq 0x24(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq $0x0, (%rax)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x2086c
movq 0x18(%rsp), %rax
movq 0x30(%rsp), %rdi
movq 0x8(%rax), %rsi
callq 0x1fb30
movq 0x18(%rsp), %rax
movq 0x30(%rsp), %rdi
movq (%rax), %rsi
callq 0x1fb30
movq 0x8(%rsp), %rdi
xorl %esi, %esi
movl $0x30, %edx
callq 0x10b0
movq 0x10(%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/minhashing.c
// Function: updateEvaluationPlan
void updateEvaluationPlan(struct EvaluationPlan p, int patternId, char match) {
	if (match) {
		rayOfLight(p.reversePoset->vertices[patternId], p);
	} else {
		rayOfDoom(p.poset->vertices[patternId], p);
	}
}

// Assembly:
subq $0x48, %rsp
movb %sil, %al
leaq 0x50(%rsp), %rcx
movq %rcx, 0x38(%rsp)
movl %edi, 0x44(%rsp)
movb %al, 0x43(%rsp)
cmpb $0x0, 0x43(%rsp)
je 0x21126
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x10(%rcx), %rcx
movslq 0x44(%rsp), %rdx
movq (%rcx,%rdx,8), %rdi
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movq %rsp, %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x21160
jmp 0x21159
movq 0x38(%rsp), %rax
movq (%rax), %rcx
movq 0x10(%rcx), %rcx
movslq 0x44(%rsp), %rdx
movq (%rcx,%rdx,8), %rdi
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movq %rsp, %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x21210
addq $0x48, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/minhashing.c
// Function: rayOfLight
static void rayOfLight(struct Vertex* v, struct EvaluationPlan p) {

	/* mark vertex as visited */
	v->visited = 1;
	p.poset->vertices[v->number]->visited = 1;


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

// Assembly:
subq $0x48, %rsp
leaq 0x50(%rsp), %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rcx
movl $0x1, 0x1c(%rcx)
movq (%rax), %rax
movq 0x10(%rax), %rax
movq 0x40(%rsp), %rcx
movslq 0x18(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movl $0x1, 0x1c(%rax)
movq 0x40(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x38(%rsp)
cmpq $0x0, 0x38(%rsp)
je 0x211fd
movq 0x38(%rsp), %rax
movq 0x18(%rax), %rax
cmpl $0x1, 0x1c(%rax)
je 0x211eb
movq 0x30(%rsp), %rax
movq 0x38(%rsp), %rcx
movq 0x18(%rcx), %rdi
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movq %rsp, %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x21160
jmp 0x211ed
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x38(%rsp)
jmp 0x211a8
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/minhashing.c
// Function: rayOfDoom
static void rayOfDoom(struct Vertex* v, struct EvaluationPlan p) {

	/* mark vertex as visited */
	v->visited = -1;
	p.reversePoset->vertices[v->number]->visited = -1;


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

// Assembly:
subq $0x48, %rsp
leaq 0x50(%rsp), %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0x40(%rsp)
movq 0x40(%rsp), %rcx
movl $0xffffffff, 0x1c(%rcx) # imm = 0xFFFFFFFF
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movq 0x40(%rsp), %rcx
movslq 0x18(%rcx), %rcx
movq (%rax,%rcx,8), %rax
movl $0xffffffff, 0x1c(%rax) # imm = 0xFFFFFFFF
movq 0x40(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x38(%rsp)
cmpq $0x0, 0x38(%rsp)
je 0x212ae
movq 0x38(%rsp), %rax
movq 0x18(%rax), %rax
cmpl $-0x1, 0x1c(%rax)
je 0x2129c
movq 0x30(%rsp), %rax
movq 0x38(%rsp), %rcx
movq 0x18(%rcx), %rdi
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movq %rsp, %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x21210
jmp 0x2129e
movq 0x38(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x38(%rsp)
jmp 0x21259
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/minhashing.c
// Function: getPositiveBorderSize
int getPositiveBorderSize(struct EvaluationPlan p) {
	int borderSize = 0;
	for (int v=0; v<p.poset->n; ++v) {
		int inBorder = 1;
		for (struct VertexList* e=p.poset->vertices[v]->neighborhood; e!=NULL; e=e->next) {
			inBorder &= getMatch(e->endPoint);
		}
		borderSize += inBorder;
	}
	return borderSize;
}

// Assembly:
subq $0x28, %rsp
leaq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movl $0x0, 0x24(%rsp)
movl $0x0, 0x20(%rsp)
movq 0x8(%rsp), %rcx
movl 0x20(%rsp), %eax
movq (%rcx), %rcx
cmpl (%rcx), %eax
jge 0x2135b
movq 0x8(%rsp), %rax
movl $0x1, 0x1c(%rsp)
movq (%rax), %rax
movq 0x10(%rax), %rax
movslq 0x20(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x21342
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x210b0
andl 0x1c(%rsp), %eax
movl %eax, 0x1c(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x21314
movl 0x1c(%rsp), %eax
addl 0x24(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x212de
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/minhashing.c
// Function: patternPosetInfoToFeatureSet
struct IntSet* patternPosetInfoToFeatureSet(struct EvaluationPlan p) {
	struct IntSet* features = getIntSet();
	for (int i=1; i<p.poset->n; ++i) {
		if (p.poset->vertices[i]->visited == 1) {
			addIntSortedNoDuplicates(features, i - 1);
		}
	}
	return features;
}

// Assembly:
subq $0x18, %rsp
leaq 0x20(%rsp), %rax
movq %rax, (%rsp)
movb $0x0, %al
callq 0xdc80
movq %rax, 0x10(%rsp)
movl $0x1, 0xc(%rsp)
movq (%rsp), %rcx
movl 0xc(%rsp), %eax
movq (%rcx), %rcx
cmpl (%rcx), %eax
jge 0x213da
movq (%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rax
cmpl $0x1, 0x1c(%rax)
jne 0x213cb
movq 0x10(%rsp), %rdi
movl 0xc(%rsp), %esi
subl $0x1, %esi
callq 0xe0c0
jmp 0x213cd
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x21391
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/minhashing.c
// Function: randomProjectionEmbeddingForTrees
int* randomProjectionEmbeddingForTrees(struct Graph* g, struct EvaluationPlan p, int* projection, int projectionSize, struct GraphPool* gp) {

	int nEvaluations = 0;
	cleanEvaluationPlan(p);

	// alloc output array
	int* approximateEmbedding = malloc(projectionSize * sizeof(int));
	if (!approximateEmbedding) {
		fprintf(stderr, "Could not allocate memory for sketch. This is a bad thing.\n");
		return NULL;
	}

	for (int i=0; i<projectionSize; ++i) {

		// if we don't know the value we need to compute it.
		int currentGraphNumber = projection[i];
		if (!embeddingValueKnown(p.poset->vertices[currentGraphNumber])) {

			// evaluate the embedding operator
			struct Graph* currentGraph = (struct Graph*)(p.poset->vertices[currentGraphNumber]->label);
			char match = isSubtree(g, currentGraph, gp);

			// update output
			approximateEmbedding[i] = match;

			// update evaluation Plan
			++nEvaluations;
			updateEvaluationPlan(p, currentGraphNumber, match);
		}
	}

	fprintf(stderr, "%i\n", nEvaluations);
	return approximateEmbedding;

}

// Assembly:
subq $0x88, %rsp
leaq 0x90(%rsp), %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movl %edx, 0x6c(%rsp)
movq %rcx, 0x60(%rsp)
movl $0x0, 0x5c(%rsp)
movups (%rax), %xmm0
movups 0x10(%rax), %xmm1
movups 0x20(%rax), %xmm2
movq %rsp, %rax
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x21020
movslq 0x6c(%rsp), %rdi
shlq $0x2, %rdi
callq 0x1170
movq %rax, 0x50(%rsp)
cmpq $0x0, 0x50(%rsp)
jne 0x22af1
movq 0x1b529(%rip), %rax     # 0x3dff8
movq (%rax), %rdi
leaq 0x1313b(%rip), %rsi     # 0x35c14
movb $0x0, %al
callq 0x1140
movq $0x0, 0x80(%rsp)
jmp 0x22bf6
movl $0x0, 0x4c(%rsp)
movl 0x4c(%rsp), %eax
cmpl 0x6c(%rsp), %eax
jge 0x22bcd
movq 0x30(%rsp), %rax
movq 0x70(%rsp), %rcx
movslq 0x4c(%rsp), %rdx
movl (%rcx,%rdx,4), %ecx
movl %ecx, 0x48(%rsp)
movq (%rax), %rax
movq 0x10(%rax), %rax
movslq 0x48(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x21090
cmpl $0x0, %eax
jne 0x22bbb
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movslq 0x48(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x78(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x60(%rsp), %rdx
callq 0xfbd0
movq 0x30(%rsp), %rcx
movb %al, 0x3f(%rsp)
movsbl 0x3f(%rsp), %esi
movq 0x50(%rsp), %rax
movslq 0x4c(%rsp), %rdx
movl %esi, (%rax,%rdx,4)
movl 0x5c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x5c(%rsp)
movl 0x48(%rsp), %edi
movb 0x3f(%rsp), %al
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups 0x20(%rcx), %xmm2
movq %rsp, %rcx
movups %xmm2, 0x20(%rcx)
movups %xmm1, 0x10(%rcx)
movups %xmm0, (%rcx)
movsbl %al, %esi
callq 0x210d0
jmp 0x22bbd
movl 0x4c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4c(%rsp)
jmp 0x22af9
movq 0x1b424(%rip), %rax     # 0x3dff8
movq (%rax), %rdi
movl 0x5c(%rsp), %edx
leaq 0x12454(%rip), %rsi     # 0x35036
movb $0x0, %al
callq 0x1140
movq 0x50(%rsp), %rax
movq %rax, 0x80(%rsp)
movq 0x80(%rsp), %rax
addq $0x88, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/newCube.c
// Function: printNewCubeCondensed
void printNewCubeCondensed(uint8_t* S, int gn, int hn, FILE* out) {
	if (S == NULL) {
		fprintf(out, "(NULL)\n");
		return;
	}
	for (int v=0; v<gn; ++v) {
		for (int u=0; u<hn; ++u) {
			fprintf(out, "(%i, %i): ", v, u);
			for (int y=0; y<hn; ++y) {
				if (getBit(S, getCharacteristicPosition(y, u, v, hn))) {
					fprintf(out, " %i", y);
				}
			}
			if (getBit(S, getCharacteristicPosition(u,u,v,hn))) {
				fprintf(out, " <- !");
			}
			fprintf(out, "\n");
		}
	}
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl %edx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
cmpq $0x0, 0x30(%rsp)
jne 0x23176
movq 0x20(%rsp), %rdi
leaq 0x12b51(%rip), %rsi     # 0x35cbb
movb $0x0, %al
callq 0x1140
jmp 0x232a3
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jge 0x232a3
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
cmpl 0x28(%rsp), %eax
jge 0x23291
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %edx
movl 0x18(%rsp), %ecx
leaq 0x12b0d(%rip), %rsi     # 0x35cc3
movb $0x0, %al
callq 0x1140
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x28(%rsp), %eax
jge 0x23229
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movslq 0x14(%rsp), %rdi
movslq 0x18(%rsp), %rsi
movslq 0x1c(%rsp), %rdx
movslq 0x28(%rsp), %rcx
callq 0x230b0
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x27d0
cmpb $0x0, %al
je 0x2321a
movq 0x20(%rsp), %rdi
movl 0x14(%rsp), %edx
leaq 0x133e0(%rip), %rsi     # 0x365f3
movb $0x0, %al
callq 0x1140
jmp 0x2321c
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x231c5
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movslq 0x18(%rsp), %rdi
movslq 0x18(%rsp), %rsi
movslq 0x1c(%rsp), %rdx
movslq 0x28(%rsp), %rcx
callq 0x230b0
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x27d0
cmpb $0x0, %al
je 0x2326e
movq 0x20(%rsp), %rdi
leaq 0x12a67(%rip), %rsi     # 0x35cce
movb $0x0, %al
callq 0x1140
movq 0x20(%rsp), %rdi
leaq 0x11e3b(%rip), %rsi     # 0x350b5
movb $0x0, %al
callq 0x1140
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x23194
jmp 0x23293
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x2317e
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/newCube.c
// Function: printNewCube
void printNewCube(uint8_t* S, int gn, int hn, FILE* out) {
	for (int v=0; v<gn; ++v) {
		for (int u=0; u<hn; ++u) {
			fprintf(out, "(%i, %i): ", v, u);
			for (int y=0; y<hn; ++y) {
				fprintf(out, "%i", getBit(S, getCharacteristicPosition(y, u, v, hn)));
			}
			fprintf(out, "\n");
		}
	}
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movl %edx, 0x28(%rsp)
movq %rcx, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jge 0x233af
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
cmpl 0x28(%rsp), %eax
jge 0x2339d
movq 0x20(%rsp), %rdi
movl 0x1c(%rsp), %edx
movl 0x18(%rsp), %ecx
leaq 0x129bd(%rip), %rsi     # 0x35cc3
movb $0x0, %al
callq 0x1140
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x28(%rsp), %eax
jge 0x2337a
movq 0x20(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movslq 0x14(%rsp), %rdi
movslq 0x18(%rsp), %rsi
movslq 0x1c(%rsp), %rdx
movslq 0x28(%rsp), %rcx
callq 0x230b0
movq (%rsp), %rdi
movq %rax, %rsi
callq 0x27d0
movq 0x8(%rsp), %rdi
movzbl %al, %edx
leaq 0x1328e(%rip), %rsi     # 0x365f4
movb $0x0, %al
callq 0x1140
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x23315
movq 0x20(%rsp), %rdi
leaq 0x11d2f(%rip), %rsi     # 0x350b5
movb $0x0, %al
callq 0x1140
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x232e4
jmp 0x2339f
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x232ce
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nop
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/outerplanar.c
// Function: isPath
char isPath(struct 	Graph* tree) {
	if (tree->m != tree->n - 1) { return 0; }
	for (int v=0; v<tree->n; ++v) {
		if (degree(tree->vertices[v]) > 2) {
			return 0;
		}
	}
	return 1;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rax
movl 0x4(%rax), %eax
movq 0x8(%rsp), %rcx
movl (%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
je 0x23fa6
movb $0x0, 0x17(%rsp)
jmp 0x23ff2
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
movq 0x8(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x23fed
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0xa440
cmpl $0x2, %eax
jle 0x23fde
movb $0x0, 0x17(%rsp)
jmp 0x23ff2
jmp 0x23fe0
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x23fae
movb $0x1, 0x17(%rsp)
movb 0x17(%rsp), %al
addq $0x18, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/outerplanar.c
// Function: isTree
char isTree(struct Graph* g) {
	if (isConnected(g)) {
		return g->m == g->n - 1;
	} else { 
		return 0;
	}
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq 0x8(%rsp), %rdi
callq 0x5760
cmpb $0x0, %al
je 0x24039
movq 0x8(%rsp), %rax
movl 0x4(%rax), %eax
movq 0x8(%rsp), %rcx
movl (%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
sete %al
andb $0x1, %al
movzbl %al, %eax
movb %al, 0x17(%rsp)
jmp 0x2403e
movb $0x0, 0x17(%rsp)
movb 0x17(%rsp), %al
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/outerplanar.c
// Function: isCactus
char isCactus(struct Graph* g, struct ShallowGraphPool* sgp) {

	/* the empty graph and singleton vertices are cactus graphs */
	if (g->n <= 1) {
		return 1;
	}

	if (isConnected(g)) {
		struct ShallowGraph* biconnectedComponents = listBiconnectedComponents(g, sgp);
		struct ShallowGraph* comp;
		int compNumber = 0;
		for (comp = biconnectedComponents; comp!=NULL; comp=comp->next) {
			if (comp->m > 1) {
				++compNumber;
			}			
		}
		/* cleanup */
		dumpShallowGraphCycle(sgp, biconnectedComponents);
		return g->m - compNumber == g->n - 1 ? 1 : 0;
	} else {
		return 0;
	}
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movq 0x28(%rsp), %rax
cmpl $0x1, (%rax)
jg 0x24072
movb $0x1, 0x37(%rsp)
jmp 0x24116
movq 0x28(%rsp), %rdi
callq 0x5760
cmpb $0x0, %al
je 0x24111
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x10700
movq %rax, 0x18(%rsp)
movl $0x0, 0xc(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x240da
movq 0x10(%rsp), %rax
cmpl $0x1, 0x10(%rax)
jle 0x240c8
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x240ca
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x240aa
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x20000
movq 0x28(%rsp), %rax
movl 0x4(%rax), %edx
subl 0xc(%rsp), %edx
movq 0x28(%rsp), %rax
movl (%rax), %esi
subl $0x1, %esi
xorl %eax, %eax
movl $0x1, %ecx
cmpl %esi, %edx
cmovel %ecx, %eax
movb %al, 0x37(%rsp)
jmp 0x24116
movb $0x0, 0x37(%rsp)
movb 0x37(%rsp), %al
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/outerplanar.c
// Function: isOuterplanarGraph
char isOuterplanarGraph(struct Graph* g, struct ShallowGraphPool* sgp, struct GraphPool* gp) {
	struct ShallowGraph* biconnectedComponents = listBiconnectedComponents(g, sgp);
	struct ShallowGraph* comp;
	char isOp = 1;
	for (comp = biconnectedComponents; comp!=NULL; comp=comp->next) {
		if (comp->m > 1) {
			isOp = isOuterplanarBlockShallow(comp, sgp, gp);
			if (isOp == 0) {
				break;
			}
		}			
	}
	/* cleanup */
	dumpShallowGraphCycle(sgp, biconnectedComponents);
	return isOp;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x10700
movq %rax, 0x18(%rsp)
movb $0x1, 0xf(%rsp)
movq 0x18(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x241a1
movq 0x10(%rsp), %rax
cmpl $0x1, 0x10(%rax)
jle 0x2418f
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
callq 0x241c0
movb %al, 0xf(%rsp)
movsbl 0xf(%rsp), %eax
cmpl $0x0, %eax
jne 0x2418d
jmp 0x241a1
jmp 0x2418f
jmp 0x24191
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x24156
movq 0x28(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x20000
movb 0xf(%rsp), %al
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/outerplanar.c
// Function: isOuterplanarBlockShallow
char isOuterplanarBlockShallow(struct ShallowGraph* original, struct ShallowGraphPool* sgp, struct GraphPool* gp) {
	struct Graph* g = shallowGraphToGraph(original, gp);
	char isOP = isOuterplanarBlock(g, sgp);
	dumpGraph(gp, g);
	return isOP;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0xb1e0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x24220
movb %al, 0x7(%rsp)
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x1fb30
movb 0x7(%rsp), %al
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/outerplanar.c
// Function: createBBTree
struct BBTree* createBBTree(struct Graph* tree, struct Graph* blocks, struct ShallowGraph* blockList, int* originalIDs, struct GraphPool* gp) {
	int i;
	struct BBTree* result = malloc(sizeof(struct BBTree));

	result->tree = tree;
	result->originalIDs = originalIDs;
	if (blocks->n > 0) {
		result->blocks = blocks;
		result->blockComponents = malloc(blocks->n * sizeof(struct ShallowGraph*));

		for (i=0; i<blocks->n; ++i) {
			result->blockComponents[i] = blockList;
			blockList = blockList->next;
		}
	} else {
		dumpGraph(gp, blocks);
		result->blockComponents = NULL;
		result->blocks = NULL;
	}

	return result;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movl $0x20, %edi
callq 0x1170
movq %rax, (%rsp)
movq 0x30(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x28(%rsp), %rax
cmpl $0x0, (%rax)
jle 0x24cdf
movq 0x28(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x28(%rsp), %rax
movslq (%rax), %rdi
shlq $0x3, %rdi
callq 0x1170
movq %rax, %rcx
movq (%rsp), %rax
movq %rcx, 0x10(%rax)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x28(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x24cdd
movq 0x20(%rsp), %rdx
movq (%rsp), %rax
movq 0x10(%rax), %rax
movslq 0xc(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x20(%rsp)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x24c9f
jmp 0x24d06
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x1fb30
movq (%rsp), %rax
movq $0x0, 0x10(%rax)
movq (%rsp), %rax
movq $0x0, 0x8(%rax)
movq (%rsp), %rax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/outerplanar.c
// Function: dumpBBTree
void dumpBBTree(struct GraphPool* gp, struct ShallowGraphPool* sgp, struct BBTree* tree) {
	if (tree) {
		dumpGraph(gp, tree->tree);
		if (tree->blocks) {
			dumpGraph(gp, tree->blocks);
			dumpShallowGraphCycle(sgp, tree->blockComponents[0]);
			free(tree->blockComponents);
		}
		if (tree->originalIDs) {
			free(tree->originalIDs);
		}
		free(tree);
	}
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
cmpq $0x0, (%rsp)
je 0x24d9a
movq 0x10(%rsp), %rdi
movq (%rsp), %rax
movq (%rax), %rsi
callq 0x1fb30
movq (%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x24d79
movq 0x10(%rsp), %rdi
movq (%rsp), %rax
movq 0x8(%rax), %rsi
callq 0x1fb30
movq 0x8(%rsp), %rdi
movq (%rsp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rsi
callq 0x20000
movq (%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x1030
movq (%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x24d91
movq (%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x1030
movq (%rsp), %rdi
callq 0x1030
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/outerplanar.c
// Function: dumpFancyBBTree
void dumpFancyBBTree(struct GraphPool* gp, struct ShallowGraphPool* sgp, struct BBTree* tree) {
	if (tree) {
		dumpGraph(gp, tree->tree);
		if (tree->blocks) {
			free(tree->blocks->vertices);
			tree->blocks->vertices = NULL;
			dumpGraph(gp, tree->blocks);
			dumpShallowGraphCycle(sgp, tree->blockComponents[0]);
			free(tree->blockComponents);
		}
		free(tree->originalIDs);
		free(tree);
	}
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
cmpq $0x0, (%rsp)
je 0x24e44
movq 0x10(%rsp), %rdi
movq (%rsp), %rax
movq (%rax), %rsi
callq 0x1fb30
movq (%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x24e2e
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rdi
callq 0x1030
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq $0x0, 0x10(%rax)
movq 0x10(%rsp), %rdi
movq (%rsp), %rax
movq 0x8(%rax), %rsi
callq 0x1fb30
movq 0x8(%rsp), %rdi
movq (%rsp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rsi
callq 0x20000
movq (%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x1030
movq (%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x1030
movq (%rsp), %rdi
callq 0x1030
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/outerplanar.c
// Function: getContainmentEdge
struct VertexList* getContainmentEdge(struct ListPool* lp) {
	struct VertexList* e = getVertexList(lp);
	e->label = malloc(2*sizeof(char));
	sprintf(e->label, "#");
	e->isStringMaster = 1;
	return e;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rdi
callq 0x1f310
movq %rax, 0x8(%rsp)
movl $0x2, %edi
callq 0x1170
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movq (%rax), %rdi
leaq 0x10efc(%rip), %rsi     # 0x35d88
movb $0x0, %al
callq 0x11f0
movq 0x8(%rsp), %rax
movl $0x1, 0x28(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/outerplanar.c
// Function: compressedBBTree
struct BBTree* compressedBBTree(struct Graph* tree, struct Graph* blocks, struct ShallowGraph* list, int** originalIDs, struct GraphPool* gp) {
	int* tmpIDs = mergeBBtree(tree, blocks);
	if (*originalIDs) {
		for (int i=0; i<tree->n - blocks->n; ++i) {
			tmpIDs[i] = (*originalIDs)[tmpIDs[i]];
		}
	}	  
	return createBBTree(tree, blocks, list, tmpIDs, gp);
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x25770
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
cmpq $0x0, (%rax)
je 0x259ef
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
movq 0x30(%rsp), %rcx
movl (%rcx), %ecx
movq 0x28(%rsp), %rdx
subl (%rdx), %ecx
cmpl %ecx, %eax
jge 0x259ed
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq 0x8(%rsp), %rcx
movslq 0x4(%rsp), %rdx
movslq (%rcx,%rdx,4), %rcx
movl (%rax,%rcx,4), %edx
movq 0x8(%rsp), %rax
movslq 0x4(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x259a4
jmp 0x259ef
movq 0x30(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x8(%rsp), %rcx
movq 0x10(%rsp), %r8
callq 0x24c20
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)