LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/poset_pathCover.c
// Function: numberOfReachableVertices
int numberOfReachableVertices(struct Vertex* v, struct ShallowGraphPool* sgp) {
	struct ShallowGraph* queue = getShallowGraph(sgp);
	int markerID = v->number;
	addToVertexQueue(v, queue, sgp);
	v->visited = markerID;

	int reachableCount = 1;

	for (struct Vertex* w=popFromVertexQueue(queue, sgp); w!=NULL; w=popFromVertexQueue(queue, sgp)) {
		for (struct VertexList* e=w->neighborhood; e!=NULL; e=e->next) {
			if (e->endPoint->visited != markerID) {
				e->endPoint->visited = markerID;
				addToVertexQueue(e->endPoint, queue, sgp);
				++reachableCount;
			}
		}
	}

	return reachableCount;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x28(%rsp), %rdi
callq 0x1fe70
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rax
movl 0x18(%rax), %eax
movl %eax, 0x1c(%rsp)
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
callq 0x32870
movl 0x1c(%rsp), %ecx
movq 0x30(%rsp), %rax
movl %ecx, 0x1c(%rax)
movl $0x1, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x328c0
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x26309
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x262ee
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movl 0x1c(%rax), %eax
cmpl 0x1c(%rsp), %eax
je 0x262dc
movl 0x1c(%rsp), %ecx
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movl %ecx, 0x1c(%rax)
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x20(%rsp), %rsi
movq 0x28(%rsp), %rdx
callq 0x32870
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x262de
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x2628f
jmp 0x262f0
movq 0x20(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x328c0
movq %rax, 0x10(%rsp)
jmp 0x26275
movl 0x18(%rsp), %eax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/poset_pathCover.c
// Function: computeAllReachabilityCounts
void computeAllReachabilityCounts(struct Graph* g, struct ShallowGraphPool* sgp) {
	for (int v=0; v<g->n; ++v) {
		g->vertices[v]->visited = -1;
	}

	for (int v=0; v<g->n; ++v) {
		g->vertices[v]->lowPoint = numberOfReachableVertices(g->vertices[v], sgp);
	}
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x26369
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movl $0xffffffff, 0x1c(%rax) # imm = 0xFFFFFFFF
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x26336
movl $0x0, (%rsp)
movl (%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x263b8
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movslq (%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x8(%rsp), %rsi
callq 0x26210
movl %eax, %ecx
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movslq (%rsp), %rdx
movq (%rax,%rdx,8), %rax
movl %ecx, 0x20(%rax)
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0x26370
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/poset_pathCover.c
// Function: printPathArray
void printPathArray(int* path, FILE* out) {
	fputc('[', out);
	for (int i=1; i<path[0]; ++i) {
		fprintf(out, "%i, ", path[i]);
	}
	fputc(']', out);
	fputc('\n', out);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
movq 0x8(%rsp), %rsi
movl $0x5b, %edi
callq 0x10f0
movl $0x1, 0x4(%rsp)
movl 0x4(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x2641f
movq 0x8(%rsp), %rdi
movq 0x10(%rsp), %rax
movslq 0x4(%rsp), %rcx
movl (%rax,%rcx,4), %edx
leaq 0xf038(%rip), %rsi      # 0x35443
movb $0x0, %al
callq 0x1140
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x263e5
movq 0x8(%rsp), %rsi
movl $0x5d, %edi
callq 0x10f0
movq 0x8(%rsp), %rsi
movl $0xa, %edi
callq 0x10f0
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/poset_pathCover.c
// Function: checkPathCover
int checkPathCover(struct Graph* g, int** pathset, size_t nPaths) {

	for (int v=0; v<g->n; ++v) {
		g->vertices[v]->visited = 0;
	}

	for (size_t i=0; i<nPaths; ++i) {
		for (int j=1; j<pathset[i][0]; ++j) {
			g->vertices[pathset[i][j]]->visited = 1;
		}
	}

	int covered = 0;
	for (int v=0; v<g->n; ++v) {
		covered += g->vertices[v]->visited;
	}

	return g->n - covered;

}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movl $0x0, -0x1c(%rsp)
movl -0x1c(%rsp), %eax
movq -0x8(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x266fa
movq -0x8(%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 0x266c7
movq $0x0, -0x28(%rsp)
movq -0x28(%rsp), %rax
cmpq -0x18(%rsp), %rax
jae 0x26777
movl $0x1, -0x2c(%rsp)
movl -0x2c(%rsp), %eax
movq -0x10(%rsp), %rcx
movq -0x28(%rsp), %rdx
movq (%rcx,%rdx,8), %rcx
cmpl (%rcx), %eax
jge 0x26765
movq -0x8(%rsp), %rax
movq 0x10(%rax), %rax
movq -0x10(%rsp), %rcx
movq -0x28(%rsp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq -0x2c(%rsp), %rdx
movslq (%rcx,%rdx,4), %rcx
movq (%rax,%rcx,8), %rax
movl $0x1, 0x1c(%rax)
movl -0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rsp)
jmp 0x26717
jmp 0x26767
movq -0x28(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x28(%rsp)
jmp 0x26703
movl $0x0, -0x30(%rsp)
movl $0x0, -0x34(%rsp)
movl -0x34(%rsp), %eax
movq -0x8(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x267be
movq -0x8(%rsp), %rax
movq 0x10(%rax), %rax
movslq -0x34(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movl 0x1c(%rax), %eax
addl -0x30(%rsp), %eax
movl %eax, -0x30(%rsp)
movl -0x34(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rsp)
jmp 0x26787
movq -0x8(%rsp), %rax
movl (%rax), %eax
subl -0x30(%rsp), %eax
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/poset_pathCover.c
// Function: countPossiblePaths
static void countPossiblePaths(struct Graph* flowInstance, size_t* nPaths) {
	// how many paths are there?
	*nPaths = 0;
	for (int v=2; v<flowInstance->n; ++v) {
		if (flowInstance->vertices[v]->visited > 0) {
			*nPaths += flowInstance->vertices[v]->visited;
		}
	}
}

// Assembly:
movq %rdi, -0x8(%rsp)
movq %rsi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq $0x0, (%rax)
movl $0x2, -0x14(%rsp)
movl -0x14(%rsp), %eax
movq -0x8(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x26d73
movq -0x8(%rsp), %rax
movq 0x10(%rax), %rax
movslq -0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rax
cmpl $0x0, 0x1c(%rax)
jle 0x26d64
movq -0x8(%rsp), %rax
movq 0x10(%rax), %rax
movslq -0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movslq 0x1c(%rax), %rcx
movq -0x10(%rsp), %rax
addq (%rax), %rcx
movq %rcx, (%rax)
jmp 0x26d66
movl -0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rsp)
jmp 0x26d1e
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/poset_pathCover.c
// Function: dfsDownwardEmbeddingForTrees
struct IntSet* dfsDownwardEmbeddingForTrees(struct Graph* g, struct EvaluationPlan p, struct GraphPool* gp) {

	int nEvaluations = 0;
	cleanEvaluationPlan(p);
	for (int i=1; i<p.poset->n; ++i) {
		nEvaluations += dfsRaySearch(g, p, p.poset->vertices[i], gp);
	}

	fprintf(stderr, "%i\n", nEvaluations);
	return patternPosetInfoToFeatureSet(p);
}

// Assembly:
subq $0x58, %rsp
leaq 0x60(%rsp), %rax
movq %rax, 0x38(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movl $0x0, 0x44(%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
movl $0x1, 0x40(%rsp)
movq 0x38(%rsp), %rcx
movl 0x40(%rsp), %eax
movq (%rcx), %rcx
cmpl (%rcx), %eax
jge 0x274b8
movq 0x38(%rsp), %rax
movq 0x50(%rsp), %rdi
movq (%rax), %rcx
movq 0x10(%rcx), %rcx
movslq 0x40(%rsp), %rdx
movq (%rcx,%rdx,8), %rsi
movq 0x48(%rsp), %rdx
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 0x27500
addl 0x44(%rsp), %eax
movl %eax, 0x44(%rsp)
movl 0x40(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x40(%rsp)
jmp 0x27456
movq 0x16b39(%rip), %rax     # 0x3dff8
movq (%rax), %rdi
movl 0x44(%rsp), %edx
leaq 0xdb69(%rip), %rsi      # 0x35036
movb $0x0, %al
callq 0x1140
movq 0x38(%rsp), %rax
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 0x21370
addq $0x58, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/poset_pathCover.c
// Function: dfsRaySearch
static int dfsRaySearch(struct Graph* g, struct EvaluationPlan p, struct Vertex* currentPattern, struct GraphPool* gp) {
	int nEvaluations = 0;
	if (!embeddingValueKnown(currentPattern)) {
		struct Graph* pattern = (struct Graph*)(currentPattern->label);
		char match = isSubtree(g, pattern, gp);
		++nEvaluations;
		if (match) {
			for (struct VertexList* e=currentPattern->neighborhood; e!=NULL; e=e->next) {
				nEvaluations += dfsRaySearch(g, p, e->endPoint, gp);
			}
			updateEvaluationPlan(p, currentPattern->number, 1);
		} else {
			updateEvaluationPlan(p, currentPattern->number, 0);
		}
	}
	return nEvaluations;
}

// Assembly:
subq $0x78, %rsp
leaq 0x80(%rsp), %rax
movq %rax, 0x38(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movl $0x0, 0x5c(%rsp)
movq 0x68(%rsp), %rdi
callq 0x21090
cmpl $0x0, %eax
jne 0x2763d
movq 0x68(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x50(%rsp)
movq 0x70(%rsp), %rdi
movq 0x50(%rsp), %rsi
movq 0x60(%rsp), %rdx
callq 0xfbd0
movb %al, 0x4f(%rsp)
movl 0x5c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x5c(%rsp)
cmpb $0x0, 0x4f(%rsp)
je 0x2760c
movq 0x68(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x40(%rsp)
cmpq $0x0, 0x40(%rsp)
je 0x275da
movq 0x38(%rsp), %rax
movq 0x70(%rsp), %rdi
movq 0x40(%rsp), %rcx
movq 0x18(%rcx), %rsi
movq 0x60(%rsp), %rdx
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 0x27500
addl 0x5c(%rsp), %eax
movl %eax, 0x5c(%rsp)
movq 0x40(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x40(%rsp)
jmp 0x27584
movq 0x38(%rsp), %rax
movq 0x68(%rsp), %rcx
movl 0x18(%rcx), %edi
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)
movl $0x1, %esi
callq 0x210d0
jmp 0x2763b
movq 0x38(%rsp), %rax
movq 0x68(%rsp), %rcx
movl 0x18(%rcx), %edi
xorl %ecx, %ecx
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)
xorl %esi, %esi
callq 0x210d0
jmp 0x2763d
movl 0x5c(%rsp), %eax
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/poset_pathCover.c
// Function: latticePathEmbeddingForTrees
struct IntSet* latticePathEmbeddingForTrees(struct Graph* g, struct EvaluationPlan p, struct GraphPool* gp) {

	int nEvaluations = 0;
	cleanEvaluationPlan(p);

	for (int i=1; i<p.poset->n; ++i) {
		if (!embeddingValueKnown(p.poset->vertices[i])) {
			int* path = getPathInDAG(p.poset->vertices[i]);
			nEvaluations += binarySearchEvaluation(g, p, path, gp);
			free(path);
		}
	}

	fprintf(stderr, "%i\n", nEvaluations);
	return patternPosetInfoToFeatureSet(p);
}

// Assembly:
subq $0x58, %rsp
leaq 0x60(%rsp), %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movl $0x0, 0x44(%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
movl $0x1, 0x40(%rsp)
movq 0x30(%rsp), %rcx
movl 0x40(%rsp), %eax
movq (%rcx), %rcx
cmpl (%rcx), %eax
jge 0x27741
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movslq 0x40(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x21090
cmpl $0x0, %eax
jne 0x2772f
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movslq 0x40(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x27790
movq %rax, %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x38(%rsp)
movq 0x50(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x48(%rsp), %rdx
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 0x278c0
addl 0x44(%rsp), %eax
movl %eax, 0x44(%rsp)
movq 0x38(%rsp), %rdi
callq 0x1030
jmp 0x27731
movl 0x40(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x40(%rsp)
jmp 0x27696
movq 0x168b0(%rip), %rax     # 0x3dff8
movq (%rax), %rdi
movl 0x44(%rsp), %edx
leaq 0xd8e0(%rip), %rsi      # 0x35036
movb $0x0, %al
callq 0x1140
movq 0x30(%rsp), %rax
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 0x21370
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/poset_pathCover.c
// Function: getPathInDAG
static int* getPathInDAG(struct Vertex* v) {
	int pathLength = 2;
	int* path = NULL;

	// DFS without backtracking in DAG
	for (struct VertexList* e=v->neighborhood; e!=NULL && (e->endPoint->visited == 0); e=e->endPoint->neighborhood) {
		++pathLength;
	}

	path = malloc(pathLength * sizeof(int));
	path[0] = pathLength;
	path[1] = v->number;

	pathLength = 2;
	// DFS without backtracking in DAG
	for (struct VertexList* e=v->neighborhood; e!=NULL && (e->endPoint->visited == 0); e=e->endPoint->neighborhood) {
		path[pathLength] = e->endPoint->number;
		++pathLength;
	}

	return path;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl $0x2, 0x2c(%rsp)
movq $0x0, 0x20(%rsp)
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
xorl %eax, %eax
cmpq $0x0, 0x18(%rsp)
movb %al, 0xf(%rsp)
je 0x277da
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rax
cmpl $0x0, 0x1c(%rax)
sete %al
movb %al, 0xf(%rsp)
movb 0xf(%rsp), %al
testb $0x1, %al
jne 0x277e4
jmp 0x27803
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
jmp 0x277b8
movslq 0x2c(%rsp), %rdi
shlq $0x2, %rdi
callq 0x1170
movq %rax, 0x20(%rsp)
movl 0x2c(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, (%rax)
movq 0x30(%rsp), %rax
movl 0x18(%rax), %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x4(%rax)
movl $0x2, 0x2c(%rsp)
movq 0x30(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
xorl %eax, %eax
cmpq $0x0, 0x10(%rsp)
movb %al, 0xe(%rsp)
je 0x27869
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
cmpl $0x0, 0x1c(%rax)
sete %al
movb %al, 0xe(%rsp)
movb 0xe(%rsp), %al
testb $0x1, %al
jne 0x27873
jmp 0x278ab
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movl 0x18(%rax), %edx
movq 0x20(%rsp), %rax
movslq 0x2c(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x27847
movq 0x20(%rsp), %rax
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/poset_pathCover.c
// Function: binarySearchEvaluation
static int binarySearchEvaluation(struct Graph* g, struct EvaluationPlan p, int* path, struct GraphPool* gp) {
	int nEvaluations = 0;
	int minIdx = 1;
	int maxIdx = path[0] - 1;

	while (minIdx <= maxIdx) {
		int currentIdx = (minIdx + maxIdx) / 2;
		char match;
		if (!embeddingValueKnown(p.poset->vertices[path[currentIdx]])) {
			struct Graph* pattern = (struct Graph*)(p.poset->vertices[path[currentIdx]]->label);
			match = isSubtree(g, pattern, gp);
			++nEvaluations;
			updateEvaluationPlan(p, path[currentIdx], match);
		} else {
			match = getMatch(p.poset->vertices[path[currentIdx]]);
		}

		if (match) {
			minIdx = currentIdx + 1;
		} else {
			maxIdx = currentIdx - 1;
		}
	}

	return nEvaluations;
}

// Assembly:
subq $0x78, %rsp
leaq 0x80(%rsp), %rax
movq %rax, 0x38(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movl $0x0, 0x5c(%rsp)
movl $0x1, 0x58(%rsp)
movq 0x68(%rsp), %rax
movl (%rax), %eax
subl $0x1, %eax
movl %eax, 0x54(%rsp)
movl 0x58(%rsp), %eax
cmpl 0x54(%rsp), %eax
jg 0x27a1b
movl 0x58(%rsp), %eax
addl 0x54(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq 0x38(%rsp), %rax
movl %ecx, 0x50(%rsp)
movq (%rax), %rax
movq 0x10(%rax), %rax
movq 0x68(%rsp), %rcx
movslq 0x50(%rsp), %rdx
movslq (%rcx,%rdx,4), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x21090
cmpl $0x0, %eax
jne 0x279d0
movq 0x38(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq 0x68(%rsp), %rcx
movslq 0x50(%rsp), %rdx
movslq (%rcx,%rdx,4), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x70(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x60(%rsp), %rdx
callq 0xfbd0
movq 0x38(%rsp), %rcx
movb %al, 0x4f(%rsp)
movl 0x5c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x5c(%rsp)
movq 0x68(%rsp), %rax
movslq 0x50(%rsp), %rdx
movl (%rax,%rdx,4), %edi
movb 0x4f(%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 0x279f7
movq 0x38(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq 0x68(%rsp), %rcx
movslq 0x50(%rsp), %rdx
movslq (%rcx,%rdx,4), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x210b0
movb %al, 0x4f(%rsp)
cmpb $0x0, 0x4f(%rsp)
je 0x27a0b
movl 0x50(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x58(%rsp)
jmp 0x27a16
movl 0x50(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x54(%rsp)
jmp 0x278fe
movl 0x5c(%rsp), %eax
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/poset_pathCover.c
// Function: latticeLongestPathEmbeddingForTrees
struct IntSet* latticeLongestPathEmbeddingForTrees(struct Graph* g, struct EvaluationPlan p, struct GraphPool* gp, struct ShallowGraphPool* sgp) {

	int nEvaluations = 0;
	cleanEvaluationPlan(p);

	for (int i=1; i<p.poset->n; ++i) {
		if (!embeddingValueKnown(p.poset->vertices[i])) {
			int* path = getLongestPathInDAG(p.poset->vertices[i], p.poset, sgp);
			nEvaluations += binarySearchEvaluation(g, p, path, gp);
			free(path);
		}
	}

	fprintf(stderr, "%i\n", nEvaluations);
	return patternPosetInfoToFeatureSet(p);
}

// Assembly:
subq $0x68, %rsp
leaq 0x70(%rsp), %rax
movq %rax, 0x38(%rsp)
movq %rdi, 0x60(%rsp)
movq %rsi, 0x58(%rsp)
movq %rdx, 0x50(%rsp)
movl $0x0, 0x4c(%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
movl $0x1, 0x48(%rsp)
movq 0x38(%rsp), %rcx
movl 0x48(%rsp), %eax
movq (%rcx), %rcx
cmpl (%rcx), %eax
jge 0x27b2e
movq 0x38(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movslq 0x48(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x21090
cmpl $0x0, %eax
jne 0x27b1c
movq 0x38(%rsp), %rax
movq (%rax), %rcx
movq 0x10(%rcx), %rcx
movslq 0x48(%rsp), %rdx
movq (%rcx,%rdx,8), %rdi
movq (%rax), %rsi
movq 0x50(%rsp), %rdx
callq 0x27b80
movq %rax, %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x40(%rsp)
movq 0x60(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x58(%rsp), %rdx
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 0x278c0
addl 0x4c(%rsp), %eax
movl %eax, 0x4c(%rsp)
movq 0x40(%rsp), %rdi
callq 0x1030
jmp 0x27b1e
movl 0x48(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x48(%rsp)
jmp 0x27a7b
movq 0x164c3(%rip), %rax     # 0x3dff8
movq (%rax), %rdi
movl 0x4c(%rsp), %edx
leaq 0xd4f3(%rip), %rsi      # 0x35036
movb $0x0, %al
callq 0x1140
movq 0x38(%rsp), %rax
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 0x21370
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/poset_pathCover.c
// Function: staticPathCoverEmbeddingForTrees
struct IntSet* staticPathCoverEmbeddingForTrees(struct Graph* g, struct EvaluationPlan p, struct GraphPool* gp) {

	int nEvaluations = 0;
	cleanEvaluationPlan(p);

	for (size_t i=0; i<p.sketchSize; ++i) {
		nEvaluations += binarySearchEvaluation(g, p, p.shrunkPermutations[i], gp);
	}

	fprintf(stderr, "%i\n", nEvaluations);
	return patternPosetInfoToFeatureSet(p);
}

// Assembly:
subq $0x58, %rsp
leaq 0x60(%rsp), %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0x50(%rsp)
movq %rsi, 0x48(%rsp)
movl $0x0, 0x44(%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
movq $0x0, 0x38(%rsp)
movq 0x30(%rsp), %rcx
movq 0x38(%rsp), %rax
cmpq 0x28(%rcx), %rax
jae 0x27e49
movq 0x30(%rsp), %rax
movq 0x50(%rsp), %rdi
movq 0x18(%rax), %rcx
movq 0x38(%rsp), %rdx
movq (%rcx,%rdx,8), %rsi
movq 0x48(%rsp), %rdx
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 0x278c0
addl 0x44(%rsp), %eax
movl %eax, 0x44(%rsp)
movq 0x38(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x38(%rsp)
jmp 0x27de7
movq 0x161a8(%rip), %rax     # 0x3dff8
movq (%rax), %rdi
movl 0x44(%rsp), %edx
leaq 0xd1d8(%rip), %rsi      # 0x35036
movb $0x0, %al
callq 0x1140
movq 0x30(%rsp), %rax
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 0x21370
addq $0x58, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/poset_pathCover.c
// Function: latticeLongestWeightedPathEmbeddingForTrees
struct IntSet* latticeLongestWeightedPathEmbeddingForTrees(struct Graph* g, struct EvaluationPlan p, int databaseSize, struct GraphPool* gp, struct ShallowGraphPool* sgp) {

	int nEvaluations = 0;
	cleanEvaluationPlan(p);

	for (int i=1; i<p.poset->n; ++i) {
		if (!embeddingValueKnown(p.poset->vertices[i])) {
			int* path = getLongestPathInDAG(p.poset->vertices[i], p.poset, sgp);
			double* weights = getWeightsOfPath(p.poset, path, databaseSize);
			nEvaluations += weightedBinarySearchEvaluation(g, p, path, weights, gp);
			free(path);
			free(weights);
		}
	}

	fprintf(stderr, "%i\n", nEvaluations);
	return patternPosetInfoToFeatureSet(p);
}

// Assembly:
subq $0x78, %rsp
leaq 0x80(%rsp), %rax
movq %rax, 0x38(%rsp)
movq %rdi, 0x70(%rsp)
movl %esi, 0x6c(%rsp)
movq %rdx, 0x60(%rsp)
movq %rcx, 0x58(%rsp)
movl $0x0, 0x54(%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
movl $0x1, 0x50(%rsp)
movq 0x38(%rsp), %rcx
movl 0x50(%rsp), %eax
movq (%rcx), %rcx
cmpl (%rcx), %eax
jge 0x27fc6
movq 0x38(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movslq 0x50(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x21090
cmpl $0x0, %eax
jne 0x27fb4
movq 0x38(%rsp), %rax
movq (%rax), %rcx
movq 0x10(%rcx), %rcx
movslq 0x50(%rsp), %rdx
movq (%rcx,%rdx,8), %rdi
movq (%rax), %rsi
movq 0x58(%rsp), %rdx
callq 0x27b80
movq %rax, %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x48(%rsp)
movq (%rax), %rdi
movq 0x48(%rsp), %rsi
movl 0x6c(%rsp), %edx
callq 0x28010
movq %rax, %rcx
movq 0x38(%rsp), %rax
movq %rcx, 0x40(%rsp)
movq 0x70(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x40(%rsp), %rdx
movq 0x60(%rsp), %rcx
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 0x280c0
addl 0x54(%rsp), %eax
movl %eax, 0x54(%rsp)
movq 0x48(%rsp), %rdi
callq 0x1030
movq 0x40(%rsp), %rdi
callq 0x1030
jmp 0x27fb6
movl 0x50(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x50(%rsp)
jmp 0x27ee2
movq 0x1602b(%rip), %rax     # 0x3dff8
movq (%rax), %rdi
movl 0x54(%rsp), %edx
leaq 0xd05b(%rip), %rsi      # 0x35036
movb $0x0, %al
callq 0x1140
movq 0x38(%rsp), %rax
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 0x21370
addq $0x78, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/poset_pathCover.c
// Function: getWeightsOfPath
static double* getWeightsOfPath(struct Graph* poset, int* path, int databaseSize) {
	double* weights = malloc(path[0] * sizeof(double));

	weights[0] = (double)path[0];
	for (int i=1; i<path[0]; ++i) {
		weights[i] = ((struct Graph*)poset->vertices[path[i]]->label)->activity / (double)databaseSize;
	}
	return weights;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl %edx, 0x14(%rsp)
movq 0x18(%rsp), %rax
movslq (%rax), %rdi
shlq $0x3, %rdi
callq 0x1170
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rax
cvtsi2sdl (%rax), %xmm0
movq 0x8(%rsp), %rax
movsd %xmm0, (%rax)
movl $0x1, 0x4(%rsp)
movl 0x4(%rsp), %eax
movq 0x18(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x280a8
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq 0x18(%rsp), %rcx
movslq 0x4(%rsp), %rdx
movslq (%rcx,%rdx,4), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rax
cvtsi2sdl 0xc(%rax), %xmm0
cvtsi2sdl 0x14(%rsp), %xmm1
divsd %xmm1, %xmm0
movq 0x8(%rsp), %rax
movslq 0x4(%rsp), %rcx
movsd %xmm0, (%rax,%rcx,8)
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x28052
movq 0x8(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/poset_pathCover.c
// Function: weightedBinarySearchEvaluation
static int weightedBinarySearchEvaluation(struct Graph* g, struct EvaluationPlan p, int* path, double* probabilities, struct GraphPool* gp) {
	size_t nEvaluations = 0;
	size_t minIdx = 1;
	size_t maxIdx = (size_t)path[0] - 1;
	size_t currentIdx = 0;

	wbs_getNextIdx(1, probabilities, &currentIdx, &minIdx, &maxIdx);

	while (minIdx <= maxIdx) {

		char match;
		if (!embeddingValueKnown(p.poset->vertices[path[currentIdx]])) {
			struct Graph* pattern = (struct Graph*)(p.poset->vertices[path[currentIdx]]->label);
			match = isSubtree(g, pattern, gp);
			++nEvaluations;
			updateEvaluationPlan(p, path[currentIdx], match);
		} else {
			match = getMatch(p.poset->vertices[path[currentIdx]]);
		}

		wbs_getNextIdx(1, probabilities, &currentIdx, &minIdx, &maxIdx);
	}

	return nEvaluations;
}

// Assembly:
subq $0x88, %rsp
leaq 0x90(%rsp), %rax
movq %rax, 0x30(%rsp)
movq %rdi, 0x80(%rsp)
movq %rsi, 0x78(%rsp)
movq %rdx, 0x70(%rsp)
movq %rcx, 0x68(%rsp)
movq $0x0, 0x60(%rsp)
movq $0x1, 0x58(%rsp)
movq 0x78(%rsp), %rax
movslq (%rax), %rax
subq $0x1, %rax
movq %rax, 0x50(%rsp)
movq $0x0, 0x48(%rsp)
movq 0x70(%rsp), %rsi
movl $0x1, %edi
leaq 0x48(%rsp), %rdx
leaq 0x58(%rsp), %rcx
leaq 0x50(%rsp), %r8
callq 0x29110
movq 0x58(%rsp), %rax
cmpq 0x50(%rsp), %rax
ja 0x28243
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq 0x78(%rsp), %rcx
movq 0x48(%rsp), %rdx
movslq (%rcx,%rdx,4), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x21090
cmpl $0x0, %eax
jne 0x281f9
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq 0x78(%rsp), %rcx
movq 0x48(%rsp), %rdx
movslq (%rcx,%rdx,4), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x80(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x68(%rsp), %rdx
callq 0xfbd0
movq 0x30(%rsp), %rcx
movb %al, 0x47(%rsp)
movq 0x60(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x60(%rsp)
movq 0x78(%rsp), %rax
movq 0x48(%rsp), %rdx
movl (%rax,%rdx,4), %edi
movb 0x47(%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 0x28220
movq 0x30(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq 0x78(%rsp), %rcx
movq 0x48(%rsp), %rdx
movslq (%rcx,%rdx,4), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x210b0
movb %al, 0x47(%rsp)
movq 0x70(%rsp), %rsi
movl $0x1, %edi
leaq 0x48(%rsp), %rdx
leaq 0x58(%rsp), %rcx
leaq 0x50(%rsp), %r8
callq 0x29110
jmp 0x28135
movq 0x60(%rsp), %rax
addq $0x88, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/poset_pathCover.c
// Function: dfsDownwardEmbeddingForLocalEasy
struct IntSet* dfsDownwardEmbeddingForLocalEasy(struct Graph* g, struct EvaluationPlan p, int sampleSize, struct GraphPool* gp, struct ShallowGraphPool* sgp) {

	struct SpanningtreeTree spTree = getSampledSpanningtreeTree(getBlockTreeT(g, sgp), sampleSize, 1, gp, sgp);

	int nEvaluations = 0;
	cleanEvaluationPlan(p);
	for (int i=1; i<p.poset->n; ++i) {
		nEvaluations += dfsRaySearchLE(&spTree, p, p.poset->vertices[i], gp);
	}

	dumpSpanningtreeTree(spTree, gp);

	fprintf(stderr, "%i\n", nEvaluations);
	return patternPosetInfoToFeatureSet(p);
}

// Assembly:
subq $0xc8, %rsp
leaq 0xd0(%rsp), %rax
movq %rax, 0x38(%rsp)
movq %rdi, 0xc0(%rsp)
movl %esi, 0xbc(%rsp)
movq %rdx, 0xb0(%rsp)
movq %rcx, 0xa8(%rsp)
movq 0xc0(%rsp), %rsi
movq 0xa8(%rsp), %rdx
leaq 0x48(%rsp), %rdi
callq 0x15fb0
movl 0xbc(%rsp), %esi
movq 0xb0(%rsp), %rcx
movq 0xa8(%rsp), %r8
movq 0x68(%rsp), %rdx
movq %rsp, %rax
movq %rdx, 0x20(%rax)
movups 0x48(%rsp), %xmm0
movups 0x58(%rsp), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
leaq 0x70(%rsp), %rdi
movl $0x1, %edx
callq 0x16fa0
movq 0x38(%rsp), %rax
movl $0x0, 0x44(%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
movl $0x1, 0x40(%rsp)
movq 0x38(%rsp), %rcx
movl 0x40(%rsp), %eax
movq (%rcx), %rcx
cmpl (%rcx), %eax
jge 0x28378
movq 0x38(%rsp), %rax
movq (%rax), %rcx
movq 0x10(%rcx), %rcx
movslq 0x40(%rsp), %rdx
movq (%rcx,%rdx,8), %rsi
movq 0xb0(%rsp), %rdx
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)
leaq 0x70(%rsp), %rdi
callq 0x28400
addl 0x44(%rsp), %eax
movl %eax, 0x44(%rsp)
movl 0x40(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x40(%rsp)
jmp 0x28313
movq 0xb0(%rsp), %rdi
movq 0xa0(%rsp), %rcx
movq %rsp, %rax
movq %rcx, 0x30(%rax)
movups 0x70(%rsp), %xmm0
movups 0x80(%rsp), %xmm1
movups 0x90(%rsp), %xmm2
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x175f0
movq 0x15c3d(%rip), %rax     # 0x3dff8
movq (%rax), %rdi
movl 0x44(%rsp), %edx
leaq 0xcc6d(%rip), %rsi      # 0x35036
movb $0x0, %al
callq 0x1140
movq 0x38(%rsp), %rax
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 0x21370
addq $0xc8, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/poset_pathCover.c
// Function: dfsRaySearchLE
static int dfsRaySearchLE(struct SpanningtreeTree* spTree, struct EvaluationPlan p, struct Vertex* currentPattern, struct GraphPool* gp) {
	int nEvaluations = 0;
	if (!embeddingValueKnown(currentPattern)) {
		struct Graph* pattern = (struct Graph*)(currentPattern->label);
		char match = subtreeCheckForSpanningtreeTree(spTree, pattern, gp);
		wipeCharacteristicsForLocalEasy(*spTree);
		++nEvaluations;
		if (match) {
			for (struct VertexList* e=currentPattern->neighborhood; e!=NULL; e=e->next) {
				nEvaluations += dfsRaySearchLE(spTree, p, e->endPoint, gp);
			}
			updateEvaluationPlan(p, currentPattern->number, 1);
		} else {
			updateEvaluationPlan(p, currentPattern->number, 0);
		}
	}
	return nEvaluations;
}

// Assembly:
subq $0x78, %rsp
leaq 0x80(%rsp), %rax
movq %rax, 0x38(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movl $0x0, 0x5c(%rsp)
movq 0x68(%rsp), %rdi
callq 0x21090
cmpl $0x0, %eax
jne 0x28568
movq 0x68(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x50(%rsp)
movq 0x70(%rsp), %rdi
movq 0x50(%rsp), %rsi
movq 0x60(%rsp), %rdx
callq 0x18030
movb %al, 0x4f(%rsp)
movq 0x70(%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
movl 0x5c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x5c(%rsp)
cmpb $0x0, 0x4f(%rsp)
je 0x28537
movq 0x68(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x40(%rsp)
cmpq $0x0, 0x40(%rsp)
je 0x28505
movq 0x38(%rsp), %rax
movq 0x70(%rsp), %rdi
movq 0x40(%rsp), %rcx
movq 0x18(%rcx), %rsi
movq 0x60(%rsp), %rdx
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 0x28400
addl 0x5c(%rsp), %eax
movl %eax, 0x5c(%rsp)
movq 0x40(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x40(%rsp)
jmp 0x284af
movq 0x38(%rsp), %rax
movq 0x68(%rsp), %rcx
movl 0x18(%rcx), %edi
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)
movl $0x1, %esi
callq 0x210d0
jmp 0x28566
movq 0x38(%rsp), %rax
movq 0x68(%rsp), %rcx
movl 0x18(%rcx), %edi
xorl %ecx, %ecx
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)
xorl %esi, %esi
callq 0x210d0
jmp 0x28568
movl 0x5c(%rsp), %eax
addq $0x78, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/poset_pathCover.c
// Function: latticePathEmbeddingForLocalEasy
struct IntSet* latticePathEmbeddingForLocalEasy(struct Graph* g, struct EvaluationPlan p, int sampleSize, struct GraphPool* gp, struct ShallowGraphPool* sgp) {

	struct SpanningtreeTree spTree = getSampledSpanningtreeTree(getBlockTreeT(g, sgp), sampleSize, 1, gp, sgp);

	int nEvaluations = 0;
	cleanEvaluationPlan(p);
	for (int i=1; i<p.poset->n; ++i) {
		if (!embeddingValueKnown(p.poset->vertices[i])) {
			int* path = getPathInDAG(p.poset->vertices[i]);
			nEvaluations += binarySearchEvaluationLE(&spTree, p, path, gp);
			free(path);
		}
	}

	dumpSpanningtreeTree(spTree, gp);

	fprintf(stderr, "%i\n", nEvaluations);
	return patternPosetInfoToFeatureSet(p);
}

// Assembly:
subq $0xd8, %rsp
leaq 0xe0(%rsp), %rax
movq %rax, 0x40(%rsp)
movq %rdi, 0xd0(%rsp)
movl %esi, 0xcc(%rsp)
movq %rdx, 0xc0(%rsp)
movq %rcx, 0xb8(%rsp)
movq 0xd0(%rsp), %rsi
movq 0xb8(%rsp), %rdx
leaq 0x58(%rsp), %rdi
callq 0x15fb0
movl 0xcc(%rsp), %esi
movq 0xc0(%rsp), %rcx
movq 0xb8(%rsp), %r8
movq 0x78(%rsp), %rdx
movq %rsp, %rax
movq %rdx, 0x20(%rax)
movups 0x58(%rsp), %xmm0
movups 0x68(%rsp), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
leaq 0x80(%rsp), %rdi
movl $0x1, %edx
callq 0x16fa0
movq 0x40(%rsp), %rax
movl $0x0, 0x54(%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
movl $0x1, 0x50(%rsp)
movq 0x40(%rsp), %rcx
movl 0x50(%rsp), %eax
movq (%rcx), %rcx
cmpl (%rcx), %eax
jge 0x286f7
movq 0x40(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movslq 0x50(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x21090
cmpl $0x0, %eax
jne 0x286e5
movq 0x40(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movslq 0x50(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x27790
movq %rax, %rcx
movq 0x40(%rsp), %rax
movq %rcx, 0x48(%rsp)
movq 0x48(%rsp), %rsi
movq 0xc0(%rsp), %rdx
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)
leaq 0x80(%rsp), %rdi
callq 0x28780
addl 0x54(%rsp), %eax
movl %eax, 0x54(%rsp)
movq 0x48(%rsp), %rdi
callq 0x1030
jmp 0x286e7
movl 0x50(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x50(%rsp)
jmp 0x28646
movq 0xc0(%rsp), %rdi
movq 0xb0(%rsp), %rcx
movq %rsp, %rax
movq %rcx, 0x30(%rax)
movups 0x80(%rsp), %xmm0
movups 0x90(%rsp), %xmm1
movups 0xa0(%rsp), %xmm2
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x175f0
movq 0x158bb(%rip), %rax     # 0x3dff8
movq (%rax), %rdi
movl 0x54(%rsp), %edx
leaq 0xc8eb(%rip), %rsi      # 0x35036
movb $0x0, %al
callq 0x1140
movq 0x40(%rsp), %rax
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 0x21370
addq $0xd8, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/poset_pathCover.c
// Function: binarySearchEvaluationLE
static int binarySearchEvaluationLE(struct SpanningtreeTree* spTree, struct EvaluationPlan p, int* path, struct GraphPool* gp) {
	int nEvaluations = 0;
	int minIdx = 1;
	int maxIdx = path[0] - 1;

	while (minIdx <= maxIdx) {
		int currentIdx = (minIdx + maxIdx) / 2;
		char match;
		if (!embeddingValueKnown(p.poset->vertices[path[currentIdx]])) {
			struct Graph* pattern = (struct Graph*)(p.poset->vertices[path[currentIdx]]->label);
			match = subtreeCheckForSpanningtreeTree(spTree, pattern, gp);
			wipeCharacteristicsForLocalEasy(*spTree);
			++nEvaluations;
			updateEvaluationPlan(p, path[currentIdx], match);
		} else {
			match = getMatch(p.poset->vertices[path[currentIdx]]);
		}

		if (match) {
			minIdx = currentIdx + 1;
		} else {
			maxIdx = currentIdx - 1;
		}
	}

	return nEvaluations;
}

// Assembly:
subq $0x78, %rsp
leaq 0x80(%rsp), %rax
movq %rax, 0x38(%rsp)
movq %rdi, 0x70(%rsp)
movq %rsi, 0x68(%rsp)
movq %rdx, 0x60(%rsp)
movl $0x0, 0x5c(%rsp)
movl $0x1, 0x58(%rsp)
movq 0x68(%rsp), %rax
movl (%rax), %eax
subl $0x1, %eax
movl %eax, 0x54(%rsp)
movl 0x58(%rsp), %eax
cmpl 0x54(%rsp), %eax
jg 0x28906
movl 0x58(%rsp), %eax
addl 0x54(%rsp), %eax
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movq 0x38(%rsp), %rax
movl %ecx, 0x50(%rsp)
movq (%rax), %rax
movq 0x10(%rax), %rax
movq 0x68(%rsp), %rcx
movslq 0x50(%rsp), %rdx
movslq (%rcx,%rdx,4), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x21090
cmpl $0x0, %eax
jne 0x288bb
movq 0x38(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq 0x68(%rsp), %rcx
movslq 0x50(%rsp), %rdx
movslq (%rcx,%rdx,4), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rax
movq %rax, 0x40(%rsp)
movq 0x70(%rsp), %rdi
movq 0x40(%rsp), %rsi
movq 0x60(%rsp), %rdx
callq 0x18030
movb %al, 0x4f(%rsp)
movq 0x70(%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 0x38(%rsp), %rcx
movl 0x5c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x5c(%rsp)
movq 0x68(%rsp), %rax
movslq 0x50(%rsp), %rdx
movl (%rax,%rdx,4), %edi
movb 0x4f(%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 0x288e2
movq 0x38(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq 0x68(%rsp), %rcx
movslq 0x50(%rsp), %rdx
movslq (%rcx,%rdx,4), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x210b0
movb %al, 0x4f(%rsp)
cmpb $0x0, 0x4f(%rsp)
je 0x288f6
movl 0x50(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x58(%rsp)
jmp 0x28901
movl 0x50(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x54(%rsp)
jmp 0x287be
movl 0x5c(%rsp), %eax
addq $0x78, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/poset_pathCover.c
// Function: latticeLongestPathEmbeddingForLocalEasy
struct IntSet* latticeLongestPathEmbeddingForLocalEasy(struct Graph* g, struct EvaluationPlan p, int sampleSize, struct GraphPool* gp, struct ShallowGraphPool* sgp) {

	struct SpanningtreeTree spTree = getSampledSpanningtreeTree(getBlockTreeT(g, sgp), sampleSize, 1, gp, sgp);

	int nEvaluations = 0;
	cleanEvaluationPlan(p);
	for (int i=1; i<p.poset->n; ++i) {
		if (!embeddingValueKnown(p.poset->vertices[i])) {
			int* path = getLongestPathInDAG(p.poset->vertices[i], p.poset, sgp);
			nEvaluations += binarySearchEvaluationLE(&spTree, p, path, gp);
			free(path);
		}
	}

	dumpSpanningtreeTree(spTree, gp);

	fprintf(stderr, "%i\n", nEvaluations);
	return patternPosetInfoToFeatureSet(p);
}

// Assembly:
subq $0xd8, %rsp
leaq 0xe0(%rsp), %rax
movq %rax, 0x40(%rsp)
movq %rdi, 0xd0(%rsp)
movl %esi, 0xcc(%rsp)
movq %rdx, 0xc0(%rsp)
movq %rcx, 0xb8(%rsp)
movq 0xd0(%rsp), %rsi
movq 0xb8(%rsp), %rdx
leaq 0x58(%rsp), %rdi
callq 0x15fb0
movl 0xcc(%rsp), %esi
movq 0xc0(%rsp), %rcx
movq 0xb8(%rsp), %r8
movq 0x78(%rsp), %rdx
movq %rsp, %rax
movq %rdx, 0x20(%rax)
movups 0x58(%rsp), %xmm0
movups 0x68(%rsp), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
leaq 0x80(%rsp), %rdi
movl $0x1, %edx
callq 0x16fa0
movq 0x40(%rsp), %rax
movl $0x0, 0x54(%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
movl $0x1, 0x50(%rsp)
movq 0x40(%rsp), %rcx
movl 0x50(%rsp), %eax
movq (%rcx), %rcx
cmpl (%rcx), %eax
jge 0x28a92
movq 0x40(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movslq 0x50(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x21090
cmpl $0x0, %eax
jne 0x28a80
movq 0x40(%rsp), %rax
movq (%rax), %rcx
movq 0x10(%rcx), %rcx
movslq 0x50(%rsp), %rdx
movq (%rcx,%rdx,8), %rdi
movq (%rax), %rsi
movq 0xb8(%rsp), %rdx
callq 0x27b80
movq %rax, %rcx
movq 0x40(%rsp), %rax
movq %rcx, 0x48(%rsp)
movq 0x48(%rsp), %rsi
movq 0xc0(%rsp), %rdx
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)
leaq 0x80(%rsp), %rdi
callq 0x28780
addl 0x54(%rsp), %eax
movl %eax, 0x54(%rsp)
movq 0x48(%rsp), %rdi
callq 0x1030
jmp 0x28a82
movl 0x50(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x50(%rsp)
jmp 0x289d6
movq 0xc0(%rsp), %rdi
movq 0xb0(%rsp), %rcx
movq %rsp, %rax
movq %rcx, 0x30(%rax)
movups 0x80(%rsp), %xmm0
movups 0x90(%rsp), %xmm1
movups 0xa0(%rsp), %xmm2
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x175f0
movq 0x15520(%rip), %rax     # 0x3dff8
movq (%rax), %rdi
movl 0x54(%rsp), %edx
leaq 0xc550(%rip), %rsi      # 0x35036
movb $0x0, %al
callq 0x1140
movq 0x40(%rsp), %rax
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 0x21370
addq $0xd8, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/poset_pathCover.c
// Function: staticPathCoverEmbeddingForLocalEasy
struct IntSet* staticPathCoverEmbeddingForLocalEasy(struct Graph* g, struct EvaluationPlan p, int sampleSize, struct GraphPool* gp, struct ShallowGraphPool* sgp) {

	struct SpanningtreeTree spTree = getSampledSpanningtreeTree(getBlockTreeT(g, sgp), sampleSize, 1, gp, sgp);

	int nEvaluations = 0;
	cleanEvaluationPlan(p);
	for (size_t i=0; i<p.sketchSize; ++i) {
		nEvaluations += binarySearchEvaluationLE(&spTree, p, p.shrunkPermutations[i], gp);
	}

	dumpSpanningtreeTree(spTree, gp);

	fprintf(stderr, "%i\n", nEvaluations);
	return patternPosetInfoToFeatureSet(p);
}

// Assembly:
subq $0xd8, %rsp
leaq 0xe0(%rsp), %rax
movq %rax, 0x40(%rsp)
movq %rdi, 0xd0(%rsp)
movl %esi, 0xcc(%rsp)
movq %rdx, 0xc0(%rsp)
movq %rcx, 0xb8(%rsp)
movq 0xd0(%rsp), %rsi
movq 0xb8(%rsp), %rdx
leaq 0x58(%rsp), %rdi
callq 0x15fb0
movl 0xcc(%rsp), %esi
movq 0xc0(%rsp), %rcx
movq 0xb8(%rsp), %r8
movq 0x78(%rsp), %rdx
movq %rsp, %rax
movq %rdx, 0x20(%rax)
movups 0x58(%rsp), %xmm0
movups 0x68(%rsp), %xmm1
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
leaq 0x80(%rsp), %rdi
movl $0x1, %edx
callq 0x16fa0
movq 0x40(%rsp), %rax
movl $0x0, 0x54(%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
movq $0x0, 0x48(%rsp)
movq 0x40(%rsp), %rcx
movq 0x48(%rsp), %rax
cmpq 0x28(%rcx), %rax
jae 0x28c4f
movq 0x40(%rsp), %rax
movq 0x18(%rax), %rcx
movq 0x48(%rsp), %rdx
movq (%rcx,%rdx,8), %rsi
movq 0xc0(%rsp), %rdx
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)
leaq 0x80(%rsp), %rdi
callq 0x28780
addl 0x54(%rsp), %eax
movl %eax, 0x54(%rsp)
movq 0x48(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x48(%rsp)
jmp 0x28be7
movq 0xc0(%rsp), %rdi
movq 0xb0(%rsp), %rcx
movq %rsp, %rax
movq %rcx, 0x30(%rax)
movups 0x80(%rsp), %xmm0
movups 0x90(%rsp), %xmm1
movups 0xa0(%rsp), %xmm2
movups %xmm2, 0x20(%rax)
movups %xmm1, 0x10(%rax)
movups %xmm0, (%rax)
callq 0x175f0
movq 0x15363(%rip), %rax     # 0x3dff8
movq (%rax), %rdi
movl 0x54(%rsp), %edx
leaq 0xc393(%rip), %rsi      # 0x35036
movb $0x0, %al
callq 0x1140
movq 0x40(%rsp), %rax
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 0x21370
addq $0xd8, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/poset_pathCover.c
// Function: weightedBinarySearchEvaluationLE
static int weightedBinarySearchEvaluationLE(struct SpanningtreeTree* spTree, struct EvaluationPlan p, int* path, double* probabilities, struct GraphPool* gp) {
	size_t nEvaluations = 0;
	size_t minIdx = 1;
	size_t maxIdx = (size_t)path[0] - 1;
	size_t currentIdx = 0;

	wbs_getNextIdx(1, probabilities, &currentIdx, &minIdx, &maxIdx);

	while (minIdx <= maxIdx) {

		char match;
		if (!embeddingValueKnown(p.poset->vertices[path[currentIdx]])) {
			struct Graph* pattern = (struct Graph*)(p.poset->vertices[path[currentIdx]]->label);
			match = subtreeCheckForSpanningtreeTree(spTree, pattern, gp);
			wipeCharacteristicsForLocalEasy(*spTree);
			++nEvaluations;
			updateEvaluationPlan(p, path[currentIdx], match);
		} else {
			match = getMatch(p.poset->vertices[path[currentIdx]]);
		}

		wbs_getNextIdx(1, probabilities, &currentIdx, &minIdx, &maxIdx);
	}

	return nEvaluations;
}

// Assembly:
subq $0x98, %rsp
leaq 0xa0(%rsp), %rax
movq %rax, 0x40(%rsp)
movq %rdi, 0x90(%rsp)
movq %rsi, 0x88(%rsp)
movq %rdx, 0x80(%rsp)
movq %rcx, 0x78(%rsp)
movq $0x0, 0x70(%rsp)
movq $0x1, 0x68(%rsp)
movq 0x88(%rsp), %rax
movslq (%rax), %rax
subq $0x1, %rax
movq %rax, 0x60(%rsp)
movq $0x0, 0x58(%rsp)
movq 0x80(%rsp), %rsi
movl $0x1, %edi
leaq 0x58(%rsp), %rdx
leaq 0x68(%rsp), %rcx
leaq 0x60(%rsp), %r8
callq 0x29110
movq 0x68(%rsp), %rax
cmpq 0x60(%rsp), %rax
ja 0x290fc
movq 0x40(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq 0x88(%rsp), %rcx
movq 0x58(%rsp), %rdx
movslq (%rcx,%rdx,4), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x21090
cmpl $0x0, %eax
jne 0x290ac
movq 0x40(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq 0x88(%rsp), %rcx
movq 0x58(%rsp), %rdx
movslq (%rcx,%rdx,4), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rax
movq %rax, 0x48(%rsp)
movq 0x90(%rsp), %rdi
movq 0x48(%rsp), %rsi
movq 0x78(%rsp), %rdx
callq 0x18030
movb %al, 0x57(%rsp)
movq 0x90(%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 0x40(%rsp), %rcx
movq 0x70(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x70(%rsp)
movq 0x88(%rsp), %rax
movq 0x58(%rsp), %rdx
movl (%rax,%rdx,4), %edi
movb 0x57(%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 0x290d6
movq 0x40(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movq 0x88(%rsp), %rcx
movq 0x58(%rsp), %rdx
movslq (%rcx,%rdx,4), %rcx
movq (%rax,%rcx,8), %rdi
callq 0x210b0
movb %al, 0x57(%rsp)
movq 0x80(%rsp), %rsi
movl $0x1, %edi
leaq 0x58(%rsp), %rdx
leaq 0x68(%rsp), %rcx
leaq 0x60(%rsp), %r8
callq 0x29110
jmp 0x28fb1
movq 0x70(%rsp), %rax
addq $0x98, %rsp
retq
nopl (%rax)