LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/localEasySubtreeIsomorphism.c
// Function: compareVertexListsGeneric
int compareVertexListsGeneric(const struct VertexList* e1, const struct VertexList* e2, int (*compar)(const struct VertexList*, const struct VertexList*)) {

	/* if this value is larger than 0 the first label is lex. larger than the second etc. */
	int returnValue = compar(e1, e2);

	/* if the two paths are identical so far wrt. labels check the next vertex on each path */
	if (returnValue == 0) {

		if ((e1->next) && (e2->next)) {
			/* if both lists have a next, proceed recursively */
			return compareVertexListsGeneric(e1->next, e2->next, compar);
		} else {
			/* if the first list is shorter, its lex. smaller */
			if ((e1->next == NULL) && (e2->next)){
				return -1;
			}
			/* if the second is shorter, this one is lex.smaller */
			if ((e2->next == NULL) && (e1->next)){
				return 1;
			}
		}

		/* if none of the cases above was chosen, both paths end here and we have to return 0 as both strings
		represented by the lists are identical */
		return 0;

	} else {
		/* if the paths differ in the current vertices, we return the return value of the comparison function */
		return returnValue;
	}
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq %rdx, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x18(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq *%rax
movl %eax, 0x4(%rsp)
cmpl $0x0, 0x4(%rsp)
jne 0x16add
movq 0x18(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x16a8d
movq 0x10(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x16a8d
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rsi
movq 0x8(%rsp), %rdx
callq 0x16a20
movl %eax, 0x24(%rsp)
jmp 0x16ae5
movq 0x18(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x16aaf
movq 0x10(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x16aaf
movl $0xffffffff, 0x24(%rsp) # imm = 0xFFFFFFFF
jmp 0x16ae5
movq 0x10(%rsp), %rax
cmpq $0x0, 0x8(%rax)
jne 0x16ad1
movq 0x18(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x16ad1
movl $0x1, 0x24(%rsp)
jmp 0x16ae5
jmp 0x16ad3
movl $0x0, 0x24(%rsp)
jmp 0x16ae5
movl 0x4(%rsp), %eax
movl %eax, 0x24(%rsp)
movl 0x24(%rsp), %eax
addq $0x28, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/localEasySubtreeIsomorphism.c
// Function: filterSortedSpanningTreeList
struct ShallowGraph* filterSortedSpanningTreeList(struct ShallowGraph* l, int (*compar)(struct ShallowGraph*, struct ShallowGraph*), struct ShallowGraphPool* sgp) {
	struct ShallowGraph* result = NULL;
	struct ShallowGraph* garbage = NULL;
	for (struct ShallowGraph* g=l; g!=NULL; /* increment is done below */) {
		if (g->next != NULL) {
			struct ShallowGraph* next = g->next;
			if (compar(g, g->next) == 0) {
				g->next = garbage;
				garbage = g;
			} else {
				g->next = result;
				result = g;
			}
			g = next;
		} else {
			// the last element should always be in the result.
			g->next = result;
			result = g;
			g = NULL;
		}
	}
	dumpShallowGraphCycle(sgp, garbage);
	return result;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x16c71
movq 0x8(%rsp), %rax
cmpq $0x0, 0x18(%rax)
je 0x16c4b
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, (%rsp)
movq 0x28(%rsp), %rax
movq 0x8(%rsp), %rdi
movq 0x8(%rsp), %rcx
movq 0x18(%rcx), %rsi
callq *%rax
cmpl $0x0, %eax
jne 0x16c28
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x16c40
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x18(%rsp)
movq (%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x16c6c
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x18(%rsp)
movq $0x0, 0x8(%rsp)
jmp 0x16bcf
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x20000
movq 0x18(%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/localEasySubtreeIsomorphism.c
// Function: filterDuplicateSpanningTrees
struct ShallowGraph* filterDuplicateSpanningTrees(struct ShallowGraph* sptrees, struct ShallowGraphPool* sgp) {
	struct ShallowGraph* filteredResult = NULL;

	// sort edges in spanning trees, count number of spts
	size_t length = 0;
	for (struct ShallowGraph* l=sptrees; l!=NULL; l=l->next) {
		sortShallowGraphEdges(l, &absCompEdges);
		++length;
	}

	filteredResult = sortListOfShallowGraphs(sptrees, length, &absCompShallowGraphs);
	filteredResult = filterSortedSpanningTreeList(filteredResult, &compareShallowGraphsAbsloute, sgp);

	return filteredResult;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x16cec
movq (%rsp), %rdi
leaq -0x2eb(%rip), %rsi      # 0x169e0
callq 0x16d30
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
movq (%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, (%rsp)
jmp 0x16cb9
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
leaq -0x1ad(%rip), %rdx      # 0x16b50
callq 0x16e70
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rdx
leaq -0x1f8(%rip), %rsi      # 0x16b20
callq 0x16ba0
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/localEasySubtreeIsomorphism.c
// Function: sortShallowGraphEdges
static void sortShallowGraphEdges(struct ShallowGraph* l, int (*compar)(const void*,const void*)) {
	if (l->m > 1) {
		// create array containing edges from l
		struct VertexList** larray = malloc(l->m * sizeof(struct VertexList*));
		larray[0] = l->edges;
		for (int i=1; i<l->m; ++i) {
			larray[i] = larray[i-1]->next;
		}

		qsort(larray, l->m, sizeof(struct VertexList*), compar);

		// change order of edges in l according to qsort
		for (int i=0; i<l->m-1; ++i) {
			larray[i]->next = larray[i+1];
		}
		larray[l->m-1]->next = NULL;
		l->edges = larray[0];
		free(larray);
	}
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x20(%rsp), %rax
cmpl $0x1, 0x10(%rax)
jle 0x16e5f
movq 0x20(%rsp), %rax
movslq 0x10(%rax), %rdi
shlq $0x3, %rdi
callq 0x1170
movq %rax, 0x10(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, (%rax)
movl $0x1, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x16dbc
movq 0x10(%rsp), %rax
movl 0xc(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rdx
movq 0x10(%rsp), %rax
movslq 0xc(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x16d7c
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rax
movslq 0x10(%rax), %rsi
movq 0x18(%rsp), %rcx
movl $0x8, %edx
callq 0x1060
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
movq 0x20(%rsp), %rcx
movl 0x10(%rcx), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x16e26
movq 0x10(%rsp), %rax
movl 0x8(%rsp), %ecx
addl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rcx
movq 0x10(%rsp), %rax
movslq 0x8(%rsp), %rdx
movq (%rax,%rdx,8), %rax
movq %rcx, 0x8(%rax)
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x16de1
movq 0x10(%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 0x10(%rsp), %rax
movq (%rax), %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rdi
callq 0x1030
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/localEasySubtreeIsomorphism.c
// Function: sortListOfShallowGraphs
static struct ShallowGraph* sortListOfShallowGraphs(struct ShallowGraph* l, size_t length, int (*compar)(const void*,const void*)) {
	if (length > 1) {
		// create array containing edges from l
		struct ShallowGraph** larray = malloc(length * sizeof(struct VertexList*));
		larray[0] = l;
		for (size_t i=1; i<length; ++i) {
			larray[i] = larray[i-1]->next;
		}

		qsort(larray, length, sizeof(struct VertexList*), compar);

		// change order of edges in l according to qsort
		for (size_t i=0; i<length-1; ++i) {
			larray[i]->next = larray[i+1];
		}
		larray[length-1]->next = NULL;
		l = larray[0];
		free(larray);
	}
	return l;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
cmpq $0x1, 0x28(%rsp)
jbe 0x16f8f
movq 0x28(%rsp), %rdi
shlq $0x3, %rdi
callq 0x1170
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, (%rax)
movq $0x1, 0x10(%rsp)
movq 0x10(%rsp), %rax
cmpq 0x28(%rsp), %rax
jae 0x16ef8
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
movq 0x18(%rax), %rdx
movq 0x18(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x10(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x16eb8
movq 0x18(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rcx
movl $0x8, %edx
callq 0x1060
movq $0x0, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq 0x28(%rsp), %rcx
subq $0x1, %rcx
cmpq %rcx, %rax
jae 0x16f5e
movq 0x18(%rsp), %rax
movq 0x8(%rsp), %rcx
movq 0x8(%rax,%rcx,8), %rcx
movq 0x18(%rsp), %rax
movq 0x8(%rsp), %rdx
movq (%rax,%rdx,8), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x8(%rsp)
jmp 0x16f1a
movq 0x18(%rsp), %rax
movq 0x28(%rsp), %rcx
subq $0x1, %rcx
movq (%rax,%rcx,8), %rax
movq $0x0, 0x18(%rax)
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x30(%rsp)
movq 0x18(%rsp), %rdi
callq 0x1030
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/localEasySubtreeIsomorphism.c
// Function: mergeShallowGraphs
static struct ShallowGraph* mergeShallowGraphs(struct ShallowGraph* list, struct ShallowGraphPool* sgp) {
	struct ShallowGraph* head = popShallowGraph(&list);

	for (struct ShallowGraph* pop=popShallowGraph(&list); pop!=NULL; pop=popShallowGraph(&list)) {
		mergeTwoShallowGraphs(head, pop, sgp);
	}
	return head;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x16420
movq %rax, 0x10(%rsp)
leaq 0x20(%rsp), %rdi
callq 0x16420
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x172a9
movq 0x10(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x18720
leaq 0x20(%rsp), %rdi
callq 0x16420
movq %rax, 0x8(%rsp)
jmp 0x1727c
movq 0x10(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/localEasySubtreeIsomorphism.c
// Function: wipeCharacteristicsForLocalEasy
void wipeCharacteristicsForLocalEasy(struct SpanningtreeTree sptTree) {
	if (sptTree.characteristics) {
		for (int v=0; v<sptTree.nRoots; ++v) {
			struct SupportSet* list = sptTree.characteristics[v];
			if (list) {
				struct SupportSetElement* tmp;
				for (struct SupportSetElement* e=list->first; e!=NULL; e=tmp) {
					tmp = e->next;
					dumpNewCube(e->data.S, e->data.g->n);
					free(e);
				}
				list->size = 0;
				list->first = list->last = NULL;
				list->next = NULL;
			}
		}
	}
}

// Assembly:
subq $0x28, %rsp
leaq 0x30(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, 0x20(%rax)
je 0x175dc
movl $0x0, 0x24(%rsp)
movq (%rsp), %rcx
movl 0x24(%rsp), %eax
cmpl 0x30(%rcx), %eax
jge 0x175da
movq (%rsp), %rax
movq 0x20(%rax), %rax
movslq 0x24(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x175c8
movq 0x18(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x17595
movq 0x8(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movl (%rax), %esi
callq 0x22fa0
movq 0x8(%rsp), %rdi
callq 0x1030
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x17550
movq 0x18(%rsp), %rax
movq $0x0, 0x18(%rax)
movq 0x18(%rsp), %rax
movq $0x0, 0x8(%rax)
movq 0x18(%rsp), %rax
movq $0x0, (%rax)
movq 0x18(%rsp), %rax
movq $0x0, 0x10(%rax)
jmp 0x175ca
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x17510
jmp 0x175dc
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/localEasySubtreeIsomorphism.c
// Function: dumpSpanningtreeTree
void dumpSpanningtreeTree(struct SpanningtreeTree sptTree, struct GraphPool* gp) {
	for (int v=0; v<sptTree.nRoots; ++v) {
		dumpGraphList(gp, sptTree.localSpanningTrees[v]);
		if (sptTree.characteristics) {
			if (sptTree.characteristics[v]) {
				struct SupportSetElement* tmp;
				for (struct SupportSetElement* e=sptTree.characteristics[v]->first; e!=NULL; e=tmp) {
					tmp = e->next;
					dumpNewCube(e->data.S, e->data.g->n);
					free(e);
				}
			}
			free(sptTree.characteristics[v]);
		}
		if (sptTree.localPostorders) {
			if (sptTree.localPostorders[v]) {
				struct PostorderList* tmp = NULL;
				for (struct PostorderList* l=sptTree.localPostorders[v]; l!=NULL; l=tmp) {
					tmp = l->next;
					free(l->postorder);
					free(l);
				}
			}
		}
	}
	free(sptTree.parents);
	free(sptTree.roots);
	free(sptTree.localSpanningTrees);
	free(sptTree.localPostorders);
	if (sptTree.characteristics) {
		free(sptTree.characteristics);
	}
}

// Assembly:
subq $0x38, %rsp
leaq 0x40(%rsp), %rax
movq %rax, (%rsp)
movq %rdi, 0x30(%rsp)
movl $0x0, 0x2c(%rsp)
movq (%rsp), %rcx
movl 0x2c(%rsp), %eax
cmpl 0x30(%rcx), %eax
jge 0x1775c
movq (%rsp), %rax
movq 0x30(%rsp), %rdi
movq 0x18(%rax), %rax
movslq 0x2c(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
callq 0x1fc60
movq (%rsp), %rax
cmpq $0x0, 0x20(%rax)
je 0x176cf
movq (%rsp), %rax
movq 0x20(%rax), %rax
movslq 0x2c(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x176b9
movq (%rsp), %rax
movq 0x20(%rax), %rax
movslq 0x2c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x176b7
movq 0x18(%rsp), %rax
movq 0x28(%rax), %rax
movq %rax, 0x20(%rsp)
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movl (%rax), %esi
callq 0x22fa0
movq 0x18(%rsp), %rdi
callq 0x1030
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
jmp 0x17672
jmp 0x176b9
movq (%rsp), %rax
movq 0x20(%rax), %rax
movslq 0x2c(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x1030
movq (%rsp), %rax
cmpq $0x0, 0x28(%rax)
je 0x1774a
movq (%rsp), %rax
movq 0x28(%rax), %rax
movslq 0x2c(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x17748
movq (%rsp), %rax
movq $0x0, 0x10(%rsp)
movq 0x28(%rax), %rax
movslq 0x2c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x17746
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rdi
callq 0x1030
movq 0x8(%rsp), %rdi
callq 0x1030
movq 0x10(%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x1770d
jmp 0x17748
jmp 0x1774a
jmp 0x1774c
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x1760a
movq (%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x1030
movq (%rsp), %rax
movq 0x8(%rax), %rdi
callq 0x1030
movq (%rsp), %rax
movq 0x18(%rax), %rdi
callq 0x1030
movq (%rsp), %rax
movq 0x28(%rax), %rdi
callq 0x1030
movq (%rsp), %rax
cmpq $0x0, 0x20(%rax)
je 0x177a8
movq (%rsp), %rax
movq 0x20(%rax), %rdi
callq 0x1030
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/localEasySubtreeIsomorphism.c
// Function: countNontrivialRoots
static int countNontrivialRoots(struct SpanningtreeTree sptTree) {
	int count = 0;
	for (int i=0; i<sptTree.nRoots; ++i) {
		if (sptTree.localSpanningTrees[i]->next) {
			++count;
		}
	}
	return count;
}

// Assembly:
leaq 0x8(%rsp), %rax
movq %rax, -0x10(%rsp)
movl $0x0, -0x4(%rsp)
movl $0x0, -0x8(%rsp)
movq -0x10(%rsp), %rcx
movl -0x8(%rsp), %eax
cmpl 0x30(%rcx), %eax
jge 0x17a2b
movq -0x10(%rsp), %rax
movq 0x18(%rax), %rax
movslq -0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rax
cmpq $0x0, 0x18(%rax)
je 0x17a1c
movl -0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rsp)
jmp 0x17a1e
movl -0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rsp)
jmp 0x179ea
movl -0x4(%rsp), %eax
retq
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/localEasySubtreeIsomorphism.c
// Function: computeCharacteristics
void computeCharacteristics(struct SubtreeIsoDataStore* current, struct SubtreeIsoDataStore* wCharacteristics, struct CachedGraph* cachedB, struct Vertex* u, struct Vertex* w, struct Vertex* wBelow, struct GraphPool* gp) {

	// compute maximum matching
	struct Graph* B = makeBipartiteInstanceFromVerticesForLocalEasyCached(*current, wCharacteristics, cachedB, u, w, wBelow, gp);
	int sizeofMatching = bipartiteMatchingEvenMoreDirty(B);
	int nNeighbors = B->number;

	// is there a subgraph iso here?
	if (sizeofMatching == nNeighbors) {
//		addCharacteristic(current, u, u, w); // in early termination we do not need to keep the books correct here
		current->foundIso = 1;

		returnCachedGraph(cachedB);
		return; // early termination when subtree iso is found
	}

	// compute partial subgraph isomorphisms
	if (sizeofMatching == nNeighbors - 1) {
		addNoncriticalVertexCharacteristics(current, B, u, w);
	}

	returnCachedGraph(cachedB);
}

// Assembly:
subq $0x68, %rsp
movq 0x70(%rsp), %rax
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x40(%rsp)
movq %r9, 0x38(%rsp)
movq 0x60(%rsp), %r10
movq 0x58(%rsp), %rdi
movq 0x50(%rsp), %rsi
movq 0x48(%rsp), %rdx
movq 0x40(%rsp), %rcx
movq 0x38(%rsp), %r8
movq 0x70(%rsp), %r9
movq 0x20(%r10), %r11
movq %rsp, %rax
movq %r11, 0x20(%rax)
movups (%r10), %xmm0
movups 0x10(%r10), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x17b20
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rdi
callq 0x21d0
movl %eax, 0x2c(%rsp)
movq 0x30(%rsp), %rax
movl 0x8(%rax), %eax
movl %eax, 0x28(%rsp)
movl 0x2c(%rsp), %eax
cmpl 0x28(%rsp), %eax
jne 0x17adb
movq 0x60(%rsp), %rax
movl $0x1, 0x20(%rax)
movq 0x50(%rsp), %rdi
callq 0x2d10
jmp 0x17b0d
movl 0x2c(%rsp), %eax
movl 0x28(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0x17b03
movq 0x60(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x48(%rsp), %rdx
movq 0x40(%rsp), %rcx
callq 0xf800
movq 0x50(%rsp), %rdi
callq 0x2d10
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/localEasySubtreeIsomorphism.c
// Function: subtreeCheckForSpanningtreeTree
char subtreeCheckForSpanningtreeTree(struct SpanningtreeTree* sptTree, struct Graph* h, struct GraphPool* gp) {

	// for each root, process each spanning tree of the v rooted components and compute characteristics
	for (int v=sptTree->nRoots-1; v>=0; --v) {
		// we need to compute characteristics for the global root, which is a special case.
		int blockDoesNotContainGlobalRoot = v==0 ? 0 : 1;

		struct Graph* localTree = NULL;
		struct PostorderList* localPostorder = NULL;
		for (localTree=sptTree->localSpanningTrees[v], localPostorder=sptTree->localPostorders[v];
				localTree!=NULL;
				localTree=localTree->next, localPostorder=localPostorder->next) {

			struct SubtreeIsoDataStore info = {0,0,0,0,0};
			info.g = localTree;
			info.h = h;
//			info.postorder = getPostorder(localTree, 0); // 0 is the root v of localTree
			info.postorder = localPostorder->postorder;
			info.S = createNewCube(info.g->n, info.h->n);

			subtreeCheckForOneBlockSpanningTree(&info, sptTree, blockDoesNotContainGlobalRoot, gp);
			appendSupportSetData(sptTree->characteristics[v], info);

//			free(info.postorder);
//			info.postorder = NULL;

			if (info.foundIso) {
				return 1;
			}
		}
	}

	return 0;
}

// Assembly:
subq $0x88, %rsp
movq %rdi, 0x78(%rsp)
movq %rsi, 0x70(%rsp)
movq %rdx, 0x68(%rsp)
movq 0x78(%rsp), %rax
movl 0x30(%rax), %eax
subl $0x1, %eax
movl %eax, 0x64(%rsp)
cmpl $0x0, 0x64(%rsp)
jl 0x1819f
movl 0x64(%rsp), %edx
movl $0x1, %eax
xorl %ecx, %ecx
cmpl $0x0, %edx
cmovel %ecx, %eax
movl %eax, 0x60(%rsp)
movq $0x0, 0x58(%rsp)
movq $0x0, 0x50(%rsp)
movq 0x78(%rsp), %rax
movq 0x18(%rax), %rax
movslq 0x64(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x58(%rsp)
movq 0x78(%rsp), %rax
movq 0x28(%rax), %rax
movslq 0x64(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x50(%rsp)
cmpq $0x0, 0x58(%rsp)
je 0x1818d
leaq 0x28(%rsp), %rdi
xorl %esi, %esi
movl $0x28, %edx
callq 0x10b0
movq 0x58(%rsp), %rax
movq %rax, 0x30(%rsp)
movq 0x70(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x50(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x28(%rsp)
movq 0x30(%rsp), %rax
movslq (%rax), %rdi
movq 0x38(%rsp), %rax
movslq (%rax), %rsi
callq 0x22ed0
movq %rax, 0x40(%rsp)
movq 0x78(%rsp), %rsi
movl 0x60(%rsp), %edx
movq 0x68(%rsp), %rcx
leaq 0x28(%rsp), %rdi
callq 0x181c0
movq 0x78(%rsp), %rax
movq 0x20(%rax), %rax
movslq 0x64(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x48(%rsp), %rcx
movq %rsp, %rax
movq %rcx, 0x20(%rax)
movups 0x28(%rsp), %xmm0
movups 0x38(%rsp), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x2fa10
cmpl $0x0, 0x48(%rsp)
je 0x1816a
movb $0x1, 0x87(%rsp)
jmp 0x181a7
jmp 0x1816c
movq 0x58(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x58(%rsp)
movq 0x50(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x50(%rsp)
jmp 0x180b5
jmp 0x1818f
movl 0x64(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0x64(%rsp)
jmp 0x18055
movb $0x0, 0x87(%rsp)
movb 0x87(%rsp), %al
addq $0x88, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/localEasySubtreeIsomorphism.c
// Function: isProbabilisticLocalSampleSubtree
char isProbabilisticLocalSampleSubtree(struct Graph* g, struct Graph* h, int nLocalTrees, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	struct BlockTree blockTree = getBlockTreeT(g, sgp);
	struct SpanningtreeTree sptTree = getSampledSpanningtreeTree(blockTree, nLocalTrees, 1, gp, sgp);

	char result = subtreeCheckForSpanningtreeTree(&sptTree, h, gp);

	dumpSpanningtreeTree(sptTree, gp);

	return result;
}

// Assembly:
subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movl %edx, 0xb4(%rsp)
movq %rcx, 0xa8(%rsp)
movq %r8, 0xa0(%rsp)
movq 0xc0(%rsp), %rsi
movq 0xa0(%rsp), %rdx
leaq 0x78(%rsp), %rdi
callq 0x15fb0
movl 0xb4(%rsp), %esi
movq 0xa8(%rsp), %rcx
movq 0xa0(%rsp), %r8
movq 0x98(%rsp), %rdx
movq %rsp, %rax
movq %rdx, 0x20(%rax)
movups 0x78(%rsp), %xmm0
movups 0x88(%rsp), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
leaq 0x40(%rsp), %rdi
movl $0x1, %edx
callq 0x16fa0
movq 0xb8(%rsp), %rsi
movq 0xa8(%rsp), %rdx
leaq 0x40(%rsp), %rdi
callq 0x18030
movb %al, 0x3f(%rsp)
movq 0xa8(%rsp), %rdi
movq 0x70(%rsp), %rcx
movq %rsp, %rax
movq %rcx, 0x30(%rax)
movups 0x40(%rsp), %xmm0
movups 0x50(%rsp), %xmm1
movups 0x60(%rsp), %xmm2
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x175f0
movb 0x3f(%rsp), %al
addq $0xc8, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/localEasySubtreeIsomorphism.c
// Function: isLocalEasySubtree
char isLocalEasySubtree(struct Graph* g, struct Graph* h, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	struct BlockTree blockTree = getBlockTreeT(g, sgp);
	struct SpanningtreeTree sptTree = getFullSpanningtreeTree(blockTree, gp, sgp);

	char result = subtreeCheckForSpanningtreeTree(&sptTree, h, gp);

	dumpSpanningtreeTree(sptTree, gp);

	return result;
}

// Assembly:
subq $0xc8, %rsp
movq %rdi, 0xc0(%rsp)
movq %rsi, 0xb8(%rsp)
movq %rdx, 0xb0(%rsp)
movq %rcx, 0xa8(%rsp)
movq 0xc0(%rsp), %rsi
movq 0xa8(%rsp), %rdx
leaq 0x80(%rsp), %rdi
callq 0x15fb0
movq 0xb0(%rsp), %rsi
movq 0xa8(%rsp), %rdx
movq 0xa0(%rsp), %rcx
movq %rsp, %rax
movq %rcx, 0x20(%rax)
movups 0x80(%rsp), %xmm0
movups 0x90(%rsp), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
leaq 0x48(%rsp), %rdi
callq 0x172c0
movq 0xb8(%rsp), %rsi
movq 0xb0(%rsp), %rdx
leaq 0x48(%rsp), %rdi
callq 0x18030
movb %al, 0x47(%rsp)
movq 0xb0(%rsp), %rdi
movq 0x78(%rsp), %rcx
movq %rsp, %rax
movq %rcx, 0x30(%rax)
movups 0x48(%rsp), %xmm0
movups 0x58(%rsp), %xmm1
movups 0x68(%rsp), %xmm2
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x175f0
movb 0x47(%rsp), %al
addq $0xc8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/localEasySubtreeIsomorphism.c
// Function: spanningTreeCombinations
struct ShallowGraph* spanningTreeCombinations(struct ShallowGraph** lists, int currentPos, int nLists, struct ShallowGraphPool* sgp) {

	struct ShallowGraph* resultList = NULL;

	if (currentPos == nLists-1) {
		for (struct ShallowGraph* g=lists[currentPos]; g!=NULL; g=g->next) {
			struct ShallowGraph* tmp = cloneShallowGraph(g, sgp);
			tmp->next = resultList;
			resultList = tmp;
		}
	} else {
		struct ShallowGraph* conquered = spanningTreeCombinations(lists, currentPos + 1, nLists, sgp);
		for (struct ShallowGraph* g=lists[currentPos]; g!=NULL; g=g->next) {
			for (struct ShallowGraph* h=conquered; h!=NULL; h=h->next) {
				struct ShallowGraph* tmp1 = cloneShallowGraph(g, sgp);
				struct ShallowGraph* tmp2 = cloneShallowGraph(h, sgp);
				mergeTwoShallowGraphs(tmp1, tmp2, sgp);
				tmp1->next = resultList;
				resultList = tmp1;
			}
		}
		// the result of the recursive invocation is now useless
		dumpShallowGraphCycle(sgp, conquered);
	}
	return resultList;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
movl %edx, 0x48(%rsp)
movq %rcx, 0x40(%rsp)
movq $0x0, 0x38(%rsp)
movl 0x4c(%rsp), %eax
movl 0x48(%rsp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jne 0x1863a
movq 0x50(%rsp), %rax
movslq 0x4c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x30(%rsp)
cmpq $0x0, 0x30(%rsp)
je 0x18635
movq 0x30(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0xbe10
movq %rax, 0x28(%rsp)
movq 0x38(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x28(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x30(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x30(%rsp)
jmp 0x185f1
jmp 0x18710
movq 0x50(%rsp), %rdi
movl 0x4c(%rsp), %esi
addl $0x1, %esi
movl 0x48(%rsp), %edx
movq 0x40(%rsp), %rcx
callq 0x185b0
movq %rax, 0x20(%rsp)
movq 0x50(%rsp), %rax
movslq 0x4c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x18701
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x186ec
movq 0x18(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0xbe10
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0xbe10
movq %rax, (%rsp)
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
movq 0x40(%rsp), %rdx
callq 0x18720
movq 0x38(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x38(%rsp)
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x18682
jmp 0x186ee
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
jmp 0x1866c
movq 0x40(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x20000
movq 0x38(%rsp), %rax
addq $0x58, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/localEasySubtreeIsomorphism.c
// Function: mergeTwoShallowGraphs
static struct ShallowGraph* mergeTwoShallowGraphs(struct ShallowGraph* first, struct ShallowGraph* second, struct ShallowGraphPool* sgp) {
	first->lastEdge->next = second->edges;
	first->lastEdge = second->lastEdge;
	first->m += second->m;

	second->edges = second->lastEdge = NULL;
	second->next = NULL;
	dumpShallowGraph(sgp, second);
	return first;
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq %rdx, (%rsp)
movq 0x8(%rsp), %rax
movq (%rax), %rcx
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x8(%rax)
movq 0x8(%rsp), %rax
movl 0x10(%rax), %ecx
movq 0x10(%rsp), %rax
addl 0x10(%rax), %ecx
movl %ecx, 0x10(%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x8(%rax)
movq 0x8(%rsp), %rax
movq $0x0, (%rax)
movq 0x8(%rsp), %rax
movq $0x0, 0x18(%rax)
movq (%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x1ff70
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/localEasySubtreeIsomorphism.c
// Function: getNumberOfDifferentSpanningForestComponentsForKSamples
int getNumberOfDifferentSpanningForestComponentsForKSamples(struct Graph* g, int k, struct GraphPool* gp, struct ShallowGraphPool* sgp) {

	// sample k spanning trees
	struct ShallowGraph* sample = runForEachConnectedComponent(&xsampleSpanningTreesUsingWilson, g, k, k, 1, gp, sgp);

	// filter out, and count the spanning trees of singleton vertices, which are empty edge lists. (otherwise boom)
	// there are exactly k duplicate empty spanning trees per singleton
	int numberOfSingletons;
	sample = filterSingletonSpanningTrees(&numberOfSingletons, sample, sgp);
	int numberOfDifferentSpanningTreeComponents = numberOfSingletons / k;

	// filter out duplicate spanning trees and count remaining ones.
	sample = filterDuplicateSpanningTrees(sample, sgp);
	for (struct ShallowGraph* t=sample; t!=NULL; t=t->next) {
		++numberOfDifferentSpanningTreeComponents;
	}

	// avoid memory leaks, access to freed memory, and free unused stuff
	dumpShallowGraphCycle(sgp, sample);

	return numberOfDifferentSpanningTreeComponents;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movq 0x40(%rsp), %rsi
movl 0x3c(%rsp), %edx
movslq 0x3c(%rsp), %rcx
movq 0x30(%rsp), %r9
movq 0x28(%rsp), %rax
leaq 0x119aa(%rip), %rdi     # 0x2b030
movl $0x1, %r8d
movq %rax, (%rsp)
callq 0x2bad0
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
leaq 0x1c(%rsp), %rdi
callq 0x19720
movq %rax, 0x20(%rsp)
movl 0x1c(%rsp), %eax
cltd
idivl 0x3c(%rsp)
movl %eax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x16c90
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x19701
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x196de
movq 0x28(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x20000
movl 0x18(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/localEasySubtreeIsomorphism.c
// Function: filterSingletonSpanningTrees
static struct ShallowGraph* filterSingletonSpanningTrees(int* nSingletons, struct ShallowGraph* l, struct ShallowGraphPool* sgp) {
	struct ShallowGraph* result = NULL;
	struct ShallowGraph* garbage = NULL;
	*nSingletons = 0;
	for (struct ShallowGraph* g=l; g!=NULL; /* increment is done below */) {
		struct ShallowGraph* next = g->next;
		if (g->m == 0) {
			g->next = garbage;
			garbage = g;
			++(*nSingletons);
		} else {
			g->next = result;
			result = g;
		}
		g = next;
	}
	dumpShallowGraphCycle(sgp, garbage);
	return result;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movq 0x30(%rsp), %rax
movl $0x0, (%rax)
movq 0x28(%rsp), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x197c3
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
cmpl $0x0, 0x10(%rax)
jne 0x197a0
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rax
movl (%rax), %ecx
addl $0x1, %ecx
movl %ecx, (%rax)
jmp 0x197b8
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x18(%rsp)
movq (%rsp), %rax
movq %rax, 0x8(%rsp)
jmp 0x1975a
movq 0x20(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x20000
movq 0x18(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/localEasySubtreeIsomorphism.c
// Function: _getPOL
static struct PostorderList* __getPOL() {
	struct PostorderList* result = malloc(sizeof(struct PostorderList));
	result->postorder = NULL;
	result->next = NULL;
	return result;
}

// Assembly:
pushq %rax
movl $0x10, %edi
callq 0x1170
movq %rax, (%rsp)
movq (%rsp), %rax
movq $0x0, (%rax)
movq (%rsp), %rax
movq $0x0, 0x8(%rax)
movq (%rsp), %rax
popq %rcx
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/lwm_embeddingOperators.c
// Function: stupidPatternEvaluation
void stupidPatternEvaluation(struct Graph** db, int nGraphs, struct Graph** patterns, int nPatterns, struct Vertex** pointers, struct GraphPool* gp) {
	int i;
	for (i=0; i<nGraphs; ++i) {
		int j;
		for (j=0; j<nPatterns; ++j) {
			if (isSubtree(db[i], patterns[j], gp)) {
				++pointers[j]->visited;
			}
		}
	}
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq %rdx, 0x20(%rsp)
movl %ecx, 0x1c(%rsp)
movq %r8, 0x10(%rsp)
movq %r9, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jge 0x198ad
movl $0x0, (%rsp)
movl (%rsp), %eax
cmpl 0x1c(%rsp), %eax
jge 0x1989e
movq 0x30(%rsp), %rax
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x20(%rsp), %rax
movslq (%rsp), %rcx
movq (%rax,%rcx,8), %rsi
movq 0x8(%rsp), %rdx
callq 0xfbd0
cmpb $0x0, %al
je 0x19891
movq 0x10(%rsp), %rax
movslq (%rsp), %rcx
movq (%rax,%rcx,8), %rax
movl 0x1c(%rax), %ecx
addl $0x1, %ecx
movl %ecx, 0x1c(%rax)
jmp 0x19893
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0x19849
jmp 0x198a0
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x19838
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/lwm_embeddingOperators.c
// Function: localEasySubtreeCheckOperatorWithResampling
struct SubtreeIsoDataStore localEasySubtreeCheckOperatorWithResampling(struct SubtreeIsoDataStore data, struct Graph* h, double importance, struct GraphPool* gp, struct ShallowGraphPool* sgp) {

	struct SubtreeIsoDataStore result = data;
	result.h = h;
	result.S = NULL;

	result.foundIso = isProbabilisticLocalSampleSubtree(result.g, result.h, (int)importance, gp, sgp);
	return result;
}

// Assembly:
subq $0x38, %rsp
movq %rsi, %rax
movq %rdi, 0x8(%rsp)
movq %rdi, %rsi
movq %rsi, 0x10(%rsp)
leaq 0x40(%rsp), %rsi
movq %rax, 0x30(%rsp)
movsd %xmm0, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movl $0x28, %edx
callq 0x1150
movq 0x8(%rsp), %rax
movq 0x30(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq $0x0, 0x18(%rax)
movq 0x8(%rax), %rdi
movq 0x10(%rax), %rsi
cvttsd2si 0x28(%rsp), %edx
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %r8
callq 0x183d0
movq 0x8(%rsp), %rdi
movb %al, %cl
movq 0x10(%rsp), %rax
movsbl %cl, %ecx
movl %ecx, 0x20(%rdi)
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/lwm_embeddingOperators.c
// Function: localEasyOperator
struct SubtreeIsoDataStore localEasyOperator(struct SubtreeIsoDataStore data, struct Graph* h, double importance, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	(void)importance; // unused
	(void)sgp; // unused

	struct SubtreeIsoDataStore result = data;
	result.h = h;
	result.S = NULL;
	struct SpanningtreeTree* sptTree = (struct SpanningtreeTree*)data.postorder;

	result.foundIso = subtreeCheckForSpanningtreeTree(sptTree, h, gp);

	// clean up the spanning tree tree
	wipeCharacteristicsForLocalEasy(*sptTree);

	return result;
}

// Assembly:
subq $0x78, %rsp
movq %rsi, %rax
movq %rdi, 0x40(%rsp)
movq %rdi, %rsi
movq %rsi, 0x48(%rsp)
leaq 0x80(%rsp), %rsi
movq %rsi, 0x38(%rsp)
movq %rax, 0x70(%rsp)
movsd %xmm0, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movl $0x28, %edx
callq 0x1150
movq 0x38(%rsp), %rax
movq 0x40(%rsp), %rdi
movq 0x70(%rsp), %rcx
movq %rcx, 0x10(%rdi)
movq $0x0, 0x18(%rdi)
movq (%rax), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rdi
movq 0x70(%rsp), %rsi
movq 0x60(%rsp), %rdx
callq 0x18030
movq 0x40(%rsp), %rdi
movsbl %al, %eax
movl %eax, 0x20(%rdi)
movq 0x50(%rsp), %rcx
movq 0x30(%rcx), %rdx
movq %rsp, %rax
movq %rdx, 0x30(%rax)
movups (%rcx), %xmm0
movups 0x10(%rcx), %xmm1
movups 0x20(%rcx), %xmm2
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x174f0
movq 0x48(%rsp), %rax
addq $0x78, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/lwm_embeddingOperators.c
// Function: subtreeRelimpOperator
struct SubtreeIsoDataStore subtreeRelimpOperator(struct SubtreeIsoDataStore data, struct Graph* h, double importance, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	(void)sgp; // unused
	struct SubtreeIsoDataStore result = data;
	result.h = h;
	result.S = NULL;
	result.foundIso = isImportantSubtreeRelative(result.g, result.h, importance, gp);
	return result;
}

// Assembly:
subq $0x38, %rsp
movq %rsi, %rax
movq %rdi, 0x8(%rsp)
movq %rdi, %rsi
movq %rsi, 0x10(%rsp)
leaq 0x40(%rsp), %rsi
movq %rax, 0x30(%rsp)
movsd %xmm0, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movl $0x28, %edx
callq 0x1150
movq 0x8(%rsp), %rax
movq 0x30(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq $0x0, 0x18(%rax)
movq 0x8(%rax), %rdi
movq 0x10(%rax), %rsi
movsd 0x28(%rsp), %xmm0
movq 0x20(%rsp), %rdx
callq 0xd9c0
movq 0x8(%rsp), %rdi
movb %al, %cl
movq 0x10(%rsp), %rax
movsbl %cl, %ecx
movl %ecx, 0x20(%rdi)
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/lwm_embeddingOperators.c
// Function: subtreeAbsimpOperator
struct SubtreeIsoDataStore subtreeAbsimpOperator(struct SubtreeIsoDataStore data, struct Graph* h, double importance, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	(void)sgp; // unused
	struct SubtreeIsoDataStore result = data;
	result.h = h;
	result.S = NULL;
	result.foundIso = isImportantSubtreeAbsolute(result.g, result.h, importance, gp);
	return result;
}

// Assembly:
subq $0x38, %rsp
movq %rsi, %rax
movq %rdi, 0x8(%rsp)
movq %rdi, %rsi
movq %rsi, 0x10(%rsp)
leaq 0x40(%rsp), %rsi
movq %rax, 0x30(%rsp)
movsd %xmm0, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movl $0x28, %edx
callq 0x1150
movq 0x8(%rsp), %rax
movq 0x30(%rsp), %rcx
movq %rcx, 0x10(%rax)
movq $0x0, 0x18(%rax)
movq 0x8(%rax), %rdi
movq 0x10(%rax), %rsi
cvttsd2si 0x28(%rsp), %edx
movq 0x20(%rsp), %rcx
callq 0xd970
movq 0x8(%rsp), %rdi
movb %al, %cl
movq 0x10(%rsp), %rax
movsbl %cl, %ecx
movl %ecx, 0x20(%rdi)
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/lwm_embeddingOperators.c
// Function: alwaysReturnTrue
struct SubtreeIsoDataStore alwaysReturnTrue(struct SubtreeIsoDataStore data, struct Graph* h, double importance, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	(void)importance; // unused
	(void)sgp; // unused
	(void)gp; // unused
	struct SubtreeIsoDataStore result = data;
	result.h = h;
	result.S = NULL;
	result.foundIso = 1;
	return result;
}

// Assembly:
subq $0x38, %rsp
movq %rsi, %rax
movq %rdi, 0x8(%rsp)
movq %rdi, %rsi
movq %rsi, 0x10(%rsp)
leaq 0x40(%rsp), %rsi
movq %rax, 0x30(%rsp)
movsd %xmm0, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movl $0x28, %edx
callq 0x1150
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movq 0x30(%rsp), %rcx
movq %rcx, 0x10(%rdi)
movq $0x0, 0x18(%rdi)
movl $0x1, 0x20(%rdi)
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/lwm_embeddingOperators.c
// Function: hopsSimpleOperator
struct SubtreeIsoDataStore hopsSimpleOperator(struct SubtreeIsoDataStore data, struct Graph* h, double importance, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	(void)gp; // unused
	(void)sgp; // unused

	struct SubtreeIsoDataStore result = {0};
	result.g = data.g;
	result.h = h;

	for (int i=0; i<importance; ++i) {
		result.foundIso = subtreeIsomorphismSampler(data.g, h);
		if (result.foundIso) {
			break;
		}
	}

	return result;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
leaq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movq %rsi, 0x40(%rsp)
movsd %xmm0, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
xorl %esi, %esi
movl $0x28, %edx
callq 0x10b0
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rdi
movq 0x8(%rax), %rax
movq %rax, 0x8(%rdi)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rdi)
movl $0x0, 0x24(%rsp)
cvtsi2sdl 0x24(%rsp), %xmm1
movsd 0x38(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x19cd8
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x40(%rsp), %rsi
callq 0x2e2a0
movb %al, %cl
movq 0x18(%rsp), %rax
movsbl %cl, %ecx
movl %ecx, 0x20(%rax)
cmpl $0x0, 0x20(%rax)
je 0x19cc9
jmp 0x19cd8
jmp 0x19ccb
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x19c8f
movq 0x8(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/lwm_embeddingOperators.c
// Function: hopsSimplerandomOperator
struct SubtreeIsoDataStore hopsSimplerandomOperator(struct SubtreeIsoDataStore data, struct Graph* h, double importance, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	(void)gp; // unused
	(void)sgp; // unused

	struct SubtreeIsoDataStore result = {0};
	result.g = data.g;
	result.h = h;

	for (int i=0; i<importance; ++i) {
		result.foundIso = subtreeIsomorphismSamplerWithImageShuffling(data.g, h);
		if (result.foundIso) {
			break;
		}
	}

	return result;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
leaq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movq %rsi, 0x40(%rsp)
movsd %xmm0, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
xorl %esi, %esi
movl $0x28, %edx
callq 0x10b0
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rdi
movq 0x8(%rax), %rax
movq %rax, 0x8(%rdi)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rdi)
movl $0x0, 0x24(%rsp)
cvtsi2sdl 0x24(%rsp), %xmm1
movsd 0x38(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x19d98
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x40(%rsp), %rsi
callq 0x2e650
movb %al, %cl
movq 0x18(%rsp), %rax
movsbl %cl, %ecx
movl %ecx, 0x20(%rax)
cmpl $0x0, 0x20(%rax)
je 0x19d89
jmp 0x19d98
jmp 0x19d8b
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x19d4f
movq 0x8(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/lwm_embeddingOperators.c
// Function: hopsSimplematchingOperator
struct SubtreeIsoDataStore hopsSimplematchingOperator(struct SubtreeIsoDataStore data, struct Graph* h, double importance, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	(void)sgp; // unused

	struct SubtreeIsoDataStore result = {0};
	result.g = data.g;
	result.h = h;

	for (int i=0; i<importance; ++i) {
		result.foundIso = subtreeIsomorphismSamplerWithProperMatching(data.g, h, gp);
		if (result.foundIso) {
			break;
		}
	}

	return result;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
leaq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movq %rsi, 0x40(%rsp)
movsd %xmm0, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
xorl %esi, %esi
movl $0x28, %edx
callq 0x10b0
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rdi
movq 0x8(%rax), %rax
movq %rax, 0x8(%rdi)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rdi)
movl $0x0, 0x24(%rsp)
cvtsi2sdl 0x24(%rsp), %xmm1
movsd 0x38(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x19e5d
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x40(%rsp), %rsi
movq 0x30(%rsp), %rdx
callq 0x2e9b0
movb %al, %cl
movq 0x18(%rsp), %rax
movsbl %cl, %ecx
movl %ecx, 0x20(%rax)
cmpl $0x0, 0x20(%rax)
je 0x19e4e
jmp 0x19e5d
jmp 0x19e50
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x19e0f
movq 0x8(%rsp), %rax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/lwm_embeddingOperators.c
// Function: hopsOperator
struct SubtreeIsoDataStore hopsOperator(struct SubtreeIsoDataStore data, struct Graph* h, double importance, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	(void)sgp; // unused

	struct SubtreeIsoDataStore result = {0};
	result.g = data.g;
	result.h = h;

	for (int i=0; i<importance; ++i) {
		result.foundIso = subtreeIsomorphismSamplerWithSampledMaximumMatching(data.g, h, gp, 0);
		if (result.foundIso) {
			break;
		}
	}

	return result;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
leaq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movq %rsi, 0x40(%rsp)
movsd %xmm0, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
xorl %esi, %esi
movl $0x28, %edx
callq 0x10b0
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rdi
movq 0x8(%rax), %rax
movq %rax, 0x8(%rdi)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rdi)
movl $0x0, 0x24(%rsp)
cvtsi2sdl 0x24(%rsp), %xmm1
movsd 0x38(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x19f1c
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x40(%rsp), %rsi
movq 0x30(%rsp), %rdx
xorl %ecx, %ecx
callq 0x2ecd0
movl %eax, %ecx
movq 0x18(%rsp), %rax
movl %ecx, 0x20(%rax)
cmpl $0x0, 0x20(%rax)
je 0x19f0d
jmp 0x19f1c
jmp 0x19f0f
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x19ecf
movq 0x8(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/lwm_embeddingOperators.c
// Function: hopsOperatorEstimate
struct SubtreeIsoDataStore hopsOperatorEstimate(struct SubtreeIsoDataStore data, struct Graph* h, double importance, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	(void)sgp; // unused

	struct SubtreeIsoDataStore result = {0};
	result.g = data.g;
	result.h = h;
	int estimate = 0;

	for (int i=0; i<importance; ++i) {
		estimate += subtreeIsomorphismSamplerWithSampledMaximumMatching(data.g, h, gp, 1);
		if (estimate < 0) {
			// int overflow
			result.foundIso = INT_MAX;
			fprintf(stderr, "Int overflow while computing average support estimate for graph %i for iteration %i (return support INT_MAX)\n", result.g->number, i);
			break;
		}
	}

	result.foundIso = ceil(estimate / importance);
	if (result.foundIso < inGraphThreshold) {
		result.foundIso = 0;
	}

	return result;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x18(%rsp)
movq %rdi, %rax
movq %rax, 0x8(%rsp)
leaq 0x50(%rsp), %rax
movq %rax, 0x10(%rsp)
movq %rsi, 0x40(%rsp)
movsd %xmm0, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
xorl %esi, %esi
movl $0x28, %edx
callq 0x10b0
movq 0x10(%rsp), %rax
movq 0x18(%rsp), %rdi
movq 0x8(%rax), %rax
movq %rax, 0x8(%rdi)
movq 0x40(%rsp), %rax
movq %rax, 0x10(%rdi)
movl $0x0, 0x24(%rsp)
movl $0x0, 0x20(%rsp)
cvtsi2sdl 0x20(%rsp), %xmm1
movsd 0x38(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x1a035
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0x40(%rsp), %rsi
movq 0x30(%rsp), %rdx
movl $0x1, %ecx
callq 0x2ecd0
addl 0x24(%rsp), %eax
movl %eax, 0x24(%rsp)
cmpl $0x0, 0x24(%rsp)
jge 0x1a026
movq 0x18(%rsp), %rax
movl $0x7fffffff, 0x20(%rax) # imm = 0x7FFFFFFF
movq 0x23ff0(%rip), %rcx     # 0x3dff8
movq (%rcx), %rdi
movq 0x8(%rax), %rax
movl 0x8(%rax), %edx
movl 0x20(%rsp), %ecx
leaq 0x1b8c9(%rip), %rsi     # 0x358e6
movb $0x0, %al
callq 0x1140
jmp 0x1a035
jmp 0x1a028
movl 0x20(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x20(%rsp)
jmp 0x19fb7
cvtsi2sdl 0x24(%rsp), %xmm0
divsd 0x38(%rsp), %xmm0
callq 0x1210
movq 0x18(%rsp), %rax
cvttsd2si %xmm0, %ecx
movl %ecx, 0x20(%rax)
cvtsi2sdl 0x20(%rax), %xmm1
movsd 0x240e9(%rip), %xmm0    # 0x3e148
ucomisd %xmm1, %xmm0
jbe 0x1a071
movq 0x18(%rsp), %rax
movl $0x0, 0x20(%rax)
movq 0x8(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/lwm_initAndCollect.c
// Function: getDB
int getDB(struct Graph*** db) {
	struct Graph* g = NULL;
	int dbSize = 0;
	int i = 0;

	while ((g = iterateFile())) {
		/* make space for storing graphs in array */
		if (dbSize <= i) {
			dbSize = dbSize == 0 ? 128 : dbSize * 2;
			*db = realloc(*db, dbSize * sizeof (struct Graph*));
		}
		/* store graph */
		(*db)[i] = g;
		++i;
	}
	return i;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl $0x0, 0x10(%rsp)
movb $0x0, %al
callq 0x13f30
movq %rax, 0x18(%rsp)
cmpq $0x0, %rax
je 0x1a129
movl 0x14(%rsp), %eax
cmpl 0x10(%rsp), %eax
jg 0x1a103
cmpl $0x0, 0x14(%rsp)
jne 0x1a0d0
movl $0x80, %eax
movl %eax, 0xc(%rsp)
jmp 0x1a0da
movl 0x14(%rsp), %eax
shll %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x14(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rdi
movslq 0x14(%rsp), %rsi
shlq $0x3, %rsi
callq 0x11a0
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq %rcx, (%rax)
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rax
movq (%rax), %rax
movslq 0x10(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x1a0a2
movl 0x10(%rsp), %eax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)