LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/poset_pathCover.c
// Function: wbs_getNextIdx
static void wbs_getNextIdx(char isMatch, double* probabilities, size_t* currentIdx, size_t* minIdx, size_t* maxIdx) {

	double probabilityOfCurrentMatch = probabilities[*currentIdx];
	double bestKnowledgeScore = 1.0; // the value of this can be at most 0.5

	if (isMatch) {
		*minIdx = *currentIdx + 1;
		for (size_t i=*minIdx; i<=*maxIdx; ++i) {
			double knowledgeScore = fabs(probabilities[i] / probabilityOfCurrentMatch - 0.5);
			if (knowledgeScore < bestKnowledgeScore) {
				*currentIdx = i;
				bestKnowledgeScore = knowledgeScore;
			} // TODO if the value increases then we can stop. this is not implemented, yet.
		}
	} else {
		*maxIdx = *currentIdx - 1;
		for (size_t i=*minIdx; i<=*maxIdx; ++i) {
			double knowledgeScore = fabs((probabilities[i] - probabilityOfCurrentMatch) / (1.0 - probabilityOfCurrentMatch) - 0.5);
			if (knowledgeScore < bestKnowledgeScore) {
				*currentIdx = i;
				bestKnowledgeScore = knowledgeScore;
			} // TODO if the value increases then we can stop. this is not implemented, yet.
		}
	}
}

// Assembly:
movb %dil, %al
movb %al, -0x1(%rsp)
movq %rsi, -0x10(%rsp)
movq %rdx, -0x18(%rsp)
movq %rcx, -0x20(%rsp)
movq %r8, -0x28(%rsp)
movq -0x10(%rsp), %rax
movq -0x18(%rsp), %rcx
movq (%rcx), %rcx
movsd (%rax,%rcx,8), %xmm0
movsd %xmm0, -0x30(%rsp)
movsd 0xcc45(%rip), %xmm0     # 0x35d90
movsd %xmm0, -0x38(%rsp)
cmpb $0x0, -0x1(%rsp)
je 0x29200
movq -0x18(%rsp), %rax
movq (%rax), %rcx
addq $0x1, %rcx
movq -0x20(%rsp), %rax
movq %rcx, (%rax)
movq -0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x40(%rsp)
movq -0x40(%rsp), %rax
movq -0x28(%rsp), %rcx
cmpq (%rcx), %rax
ja 0x291fb
movq -0x10(%rsp), %rax
movq -0x40(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
divsd -0x30(%rsp), %xmm0
movsd 0xcbef(%rip), %xmm1     # 0x35d98
subsd %xmm1, %xmm0
movaps 0xcbec(%rip), %xmm1     # 0x35da0
pand %xmm1, %xmm0
movsd %xmm0, -0x48(%rsp)
movsd -0x48(%rsp), %xmm1
movsd -0x38(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x291e9
movq -0x40(%rsp), %rcx
movq -0x18(%rsp), %rax
movq %rcx, (%rax)
movsd -0x48(%rsp), %xmm0
movsd %xmm0, -0x38(%rsp)
jmp 0x291eb
movq -0x40(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x40(%rsp)
jmp 0x2917d
jmp 0x292ba
movq -0x18(%rsp), %rax
movq (%rax), %rcx
subq $0x1, %rcx
movq -0x28(%rsp), %rax
movq %rcx, (%rax)
movq -0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x50(%rsp)
movq -0x50(%rsp), %rax
movq -0x28(%rsp), %rcx
cmpq (%rcx), %rax
ja 0x292b8
movq -0x10(%rsp), %rax
movq -0x50(%rsp), %rcx
movsd (%rax,%rcx,8), %xmm0
subsd -0x30(%rsp), %xmm0
movsd 0xcb3f(%rip), %xmm1     # 0x35d90
subsd -0x30(%rsp), %xmm1
divsd %xmm1, %xmm0
movsd 0xcb35(%rip), %xmm1     # 0x35d98
subsd %xmm1, %xmm0
movaps 0xcb32(%rip), %xmm1     # 0x35da0
pand %xmm1, %xmm0
movsd %xmm0, -0x58(%rsp)
movsd -0x58(%rsp), %xmm1
movsd -0x38(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x292a3
movq -0x50(%rsp), %rcx
movq -0x18(%rsp), %rax
movq %rcx, (%rax)
movsd -0x58(%rsp), %xmm0
movsd %xmm0, -0x38(%rsp)
jmp 0x292a5
movq -0x50(%rsp), %rax
addq $0x1, %rax
movq %rax, -0x50(%rsp)
jmp 0x29221
jmp 0x292ba
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/randomGraphGenerators.c
// Function: generateGaussianNoise
void generateGaussianNoise(double* z0, double* z1, double mu, double sigma) {
	static const double epsilon = DBL_EPSILON;
	static const double two_pi = 2.0*3.14159265358979323846;

	double u1, u2;
	do {
		u1 = rand() * (1.0 / RAND_MAX);
		u2 = rand() * (1.0 / RAND_MAX);
	} while ( u1 <= epsilon );

	*z0 = sqrt(-2.0 * log(u1)) * cos(two_pi * u2) * sigma + mu;
	*z1 = sqrt(-2.0 * log(u1)) * sin(two_pi * u2) * sigma + mu;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movsd %xmm0, 0x30(%rsp)
movsd %xmm1, 0x28(%rsp)
callq 0x1220
cvtsi2sd %eax, %xmm0
movsd 0xcb9d(%rip), %xmm1     # 0x35e88
mulsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
callq 0x1220
cvtsi2sd %eax, %xmm0
movsd 0xcb82(%rip), %xmm1     # 0x35e88
mulsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0xcb78(%rip), %xmm0     # 0x35e90
ucomisd 0x20(%rsp), %xmm0
jae 0x292da
movsd 0x20(%rsp), %xmm0
callq 0x10d0
movaps %xmm0, %xmm1
movsd 0xcb6a(%rip), %xmm0     # 0x35ea0
mulsd %xmm1, %xmm0
callq 0x1200
movsd %xmm0, 0x8(%rsp)
movsd 0xcb4b(%rip), %xmm0     # 0x35e98
mulsd 0x18(%rsp), %xmm0
callq 0x10e0
movaps %xmm0, %xmm1
movsd 0x8(%rsp), %xmm0
mulsd %xmm1, %xmm0
movsd 0x28(%rsp), %xmm2
movsd 0x30(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq 0x40(%rsp), %rax
movsd %xmm0, (%rax)
movsd 0x20(%rsp), %xmm0
callq 0x10d0
movaps %xmm0, %xmm1
movsd 0xcb08(%rip), %xmm0     # 0x35ea0
mulsd %xmm1, %xmm0
callq 0x1200
movsd %xmm0, 0x10(%rsp)
movsd 0xcae9(%rip), %xmm0     # 0x35e98
mulsd 0x18(%rsp), %xmm0
callq 0x11d0
movaps %xmm0, %xmm1
movsd 0x10(%rsp), %xmm0
mulsd %xmm1, %xmm0
movsd 0x28(%rsp), %xmm2
movsd 0x30(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movq 0x38(%rsp), %rax
movsd %xmm0, (%rax)
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/randomGraphGenerators.c
// Function: generateIntegerGaussianNoise
void generateIntegerGaussianNoise(int* z0, int* z1, double sigma) {
	static const double epsilon = DBL_EPSILON;
	static const double two_pi = 2.0*3.14159265358979323846;

	double u1, u2;
	do {
		u1 = rand() * (1.0 / RAND_MAX);
		u2 = rand() * (1.0 / RAND_MAX);
	} while ( u1 <= epsilon );

	*z0 = *z0 + (sqrt(-2.0 * log(u1)) * cos(two_pi * u2) * sigma) * RAND_MAX;
	*z1 = *z1 + (sqrt(-2.0 * log(u1)) * sin(two_pi * u2) * sigma) * RAND_MAX;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movsd %xmm0, 0x30(%rsp)
callq 0x1220
cvtsi2sd %eax, %xmm0
movsd 0xca73(%rip), %xmm1     # 0x35e88
mulsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rsp)
callq 0x1220
cvtsi2sd %eax, %xmm0
movsd 0xca58(%rip), %xmm1     # 0x35e88
mulsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0xca4e(%rip), %xmm0     # 0x35e90
ucomisd 0x28(%rsp), %xmm0
jae 0x29404
movq 0x40(%rsp), %rax
cvtsi2sdl (%rax), %xmm0
movsd %xmm0, (%rsp)
movsd 0x28(%rsp), %xmm0
callq 0x10d0
movaps %xmm0, %xmm1
movsd 0xca32(%rip), %xmm0     # 0x35ea0
mulsd %xmm1, %xmm0
callq 0x1200
movsd %xmm0, 0x8(%rsp)
movsd 0xca13(%rip), %xmm0     # 0x35e98
mulsd 0x20(%rsp), %xmm0
callq 0x10e0
movsd (%rsp), %xmm1
movaps %xmm0, %xmm2
movsd 0x8(%rsp), %xmm0
mulsd %xmm2, %xmm0
mulsd 0x30(%rsp), %xmm0
movsd 0xc9f8(%rip), %xmm2     # 0x35ea8
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %ecx
movq 0x40(%rsp), %rax
movl %ecx, (%rax)
movq 0x38(%rsp), %rax
cvtsi2sdl (%rax), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x28(%rsp), %xmm0
callq 0x10d0
movaps %xmm0, %xmm1
movsd 0xc9b8(%rip), %xmm0     # 0x35ea0
mulsd %xmm1, %xmm0
callq 0x1200
movsd %xmm0, 0x18(%rsp)
movsd 0xc999(%rip), %xmm0     # 0x35e98
mulsd 0x20(%rsp), %xmm0
callq 0x11d0
movsd 0x10(%rsp), %xmm1
movaps %xmm0, %xmm2
movsd 0x18(%rsp), %xmm0
mulsd %xmm2, %xmm0
mulsd 0x30(%rsp), %xmm0
movsd 0xc97d(%rip), %xmm2     # 0x35ea8
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
cvttsd2si %xmm0, %ecx
movq 0x38(%rsp), %rax
movl %ecx, (%rax)
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/randomGraphGenerators.c
// Function: randomVertexLabels
void randomVertexLabels(struct Graph* g, int nVertexLabels) {
	int i;
	for (i=0; i<g->n; ++i) {
		g->vertices[i]->label = intLabel(rand() % nVertexLabels);
		g->vertices[i]->isStringMaster = 1;
	}
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl %esi, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
movq 0x10(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x295c1
callq 0x1220
cltd
idivl 0xc(%rsp)
movl %edx, %edi
callq 0x14ae0
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x8(%rsp), %rdx
movq (%rax,%rdx,8), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movl $0x1, 0x24(%rax)
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x29565
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/randomGraphGenerators.c
// Function: makeMinDegree1
void makeMinDegree1(struct Graph* g, struct GraphPool* gp) {
	for (int v=1; v<g->n; ++v) {
		if (g->vertices[v]->neighborhood == NULL) {
			addEdgeBetweenVertices(v, v-1, intLabel(1), g, gp);
			g->vertices[v]->neighborhood->isStringMaster = 1;
		}
	}
	if (g->vertices[0]->neighborhood == NULL) {
		addEdgeBetweenVertices(0,1,intLabel(1), g, gp);
		g->vertices[0]->neighborhood->isStringMaster = 1;
	}
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl $0x1, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x29672
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rax
cmpq $0x0, 0x8(%rax)
jne 0x29660
movl 0x14(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0x14(%rsp), %eax
subl $0x1, %eax
movl %eax, 0x10(%rsp)
movl $0x1, %edi
callq 0x14ae0
movl 0xc(%rsp), %edi
movl 0x10(%rsp), %esi
movq %rax, %rdx
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %r8
callq 0xb670
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
movl $0x1, 0x28(%rax)
jmp 0x29662
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x295e6
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
cmpq $0x0, 0x8(%rax)
jne 0x296bf
movl $0x1, %edi
callq 0x14ae0
movq %rax, %rdx
movq 0x20(%rsp), %rcx
movq 0x18(%rsp), %r8
xorl %edi, %edi
movl $0x1, %esi
callq 0xb670
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movq (%rax), %rax
movq 0x8(%rax), %rax
movl $0x1, 0x28(%rax)
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/randomGraphGenerators.c
// Function: erdosRenyi
struct Graph* erdosRenyi(int n, double p, struct GraphPool* gp) {
	struct Graph* g = createGraph(n, gp);
	for (int i=0; i<n; ++i) {
		for (int j=i+1; j<n; ++j) {
			double value = rand() / (RAND_MAX + 1.0);
			if (value < p) {
				addEdgeBetweenVertices(i, j, NULL, g, gp);
			}
		}
	}
	return g;
}

// Assembly:
subq $0x38, %rsp
movl %edi, 0x34(%rsp)
movsd %xmm0, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl 0x34(%rsp), %edi
movq 0x20(%rsp), %rsi
callq 0xb850
movq %rax, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x34(%rsp), %eax
jge 0x29786
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x34(%rsp), %eax
jge 0x29774
callq 0x1220
cvtsi2sd %eax, %xmm0
movsd 0xc782(%rip), %xmm1     # 0x35eb0
divsd %xmm1, %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x8(%rsp), %xmm1
movsd 0x28(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x29765
movl 0x14(%rsp), %edi
movl 0x10(%rsp), %esi
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %r8
xorl %eax, %eax
movl %eax, %edx
callq 0xb670
jmp 0x29767
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x29713
jmp 0x29776
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x296fe
movq 0x18(%rsp), %rax
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/randomGraphGenerators.c
// Function: erdosRenyiWithLabels
struct Graph* erdosRenyiWithLabels(int n, double p, int nVertexLabels, int nEdgeLabels, struct GraphPool* gp) {
	struct Graph* g = createGraph(n, gp);
	randomVertexLabels(g, nVertexLabels);

	for (int i=0; i<n; ++i) {
		for (int j=i+1; j<n; ++j) {
			double value = rand() / (RAND_MAX + 1.0);
			if (value < p) {
				// add a labeled edge and set one of the two resulting vertex lists as string master.
				addEdgeBetweenVertices(i, j, intLabel(rand() % nEdgeLabels), g, gp);
				g->vertices[i]->neighborhood->isStringMaster = 1;
			}
		}
	}
	return g;
}

// Assembly:
subq $0x48, %rsp
movl %edi, 0x44(%rsp)
movsd %xmm0, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movl %edx, 0x30(%rsp)
movq %rcx, 0x28(%rsp)
movl 0x44(%rsp), %edi
movq 0x28(%rsp), %rsi
callq 0xb850
movq %rax, 0x20(%rsp)
movq 0x20(%rsp), %rdi
movl 0x34(%rsp), %esi
callq 0x29550
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x44(%rsp), %eax
jge 0x298a4
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
movl 0x18(%rsp), %eax
cmpl 0x44(%rsp), %eax
jge 0x29892
callq 0x1220
cvtsi2sd %eax, %xmm0
movsd 0xc6a4(%rip), %xmm1     # 0x35eb0
divsd %xmm1, %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x10(%rsp), %xmm1
movsd 0x38(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x29880
movl 0x1c(%rsp), %eax
movl %eax, 0x8(%rsp)
movl 0x18(%rsp), %eax
movl %eax, 0xc(%rsp)
callq 0x1220
cltd
idivl 0x30(%rsp)
movl %edx, %edi
callq 0x14ae0
movl 0x8(%rsp), %edi
movl 0xc(%rsp), %esi
movq %rax, %rdx
movq 0x20(%rsp), %rcx
movq 0x28(%rsp), %r8
callq 0xb670
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x1c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
movl $0x1, 0x28(%rax)
jmp 0x29882
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x297ed
jmp 0x29894
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x297d4
movq 0x20(%rsp), %rax
addq $0x48, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/randomGraphGenerators.c
// Function: euclideanDistance
inline double euclideanDistance(const int vx, const int vy, const int wx, const int wy) {
	double vxx = vx / (double)RAND_MAX;
	double vyy = vy / (double)RAND_MAX;
	double wxx = wx / (double)RAND_MAX;
	double wyy = wy / (double)RAND_MAX;
	double xdiff = vxx - wxx;
	double ydiff = vyy - wyy;
	double result = sqrt(xdiff * xdiff + ydiff * ydiff);
	return result;
}

// Assembly:
subq $0x48, %rsp
movl %edi, 0x44(%rsp)
movl %esi, 0x40(%rsp)
movl %edx, 0x3c(%rsp)
movl %ecx, 0x38(%rsp)
cvtsi2sdl 0x44(%rsp), %xmm0
movsd 0xbc06(%rip), %xmm1     # 0x35ea8
divsd %xmm1, %xmm0
movsd %xmm0, 0x30(%rsp)
cvtsi2sdl 0x40(%rsp), %xmm0
movsd 0xbbee(%rip), %xmm1     # 0x35ea8
divsd %xmm1, %xmm0
movsd %xmm0, 0x28(%rsp)
cvtsi2sdl 0x3c(%rsp), %xmm0
movsd 0xbbd6(%rip), %xmm1     # 0x35ea8
divsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
cvtsi2sdl 0x38(%rsp), %xmm0
movsd 0xbbbe(%rip), %xmm1     # 0x35ea8
divsd %xmm1, %xmm0
movsd %xmm0, 0x18(%rsp)
movsd 0x30(%rsp), %xmm0
subsd 0x20(%rsp), %xmm0
movsd %xmm0, 0x10(%rsp)
movsd 0x28(%rsp), %xmm0
subsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x8(%rsp)
movsd 0x10(%rsp), %xmm0
movsd 0x10(%rsp), %xmm2
movsd 0x8(%rsp), %xmm1
mulsd 0x8(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
callq 0x1200
movsd %xmm0, (%rsp)
movsd (%rsp), %xmm0
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/randomGraphGenerators.c
// Function: printOverlapGraphDotFormat
void printOverlapGraphDotFormat(struct Graph* g, FILE* out) {
	fprintf(out, "graph %i {\n", g->number);
	for (int v=0; v<g->n; ++v) {
		fprintf(out, "%i [label=%s, pos=\"%lf,%lf\", pin=true, shape=point];\n", v, g->vertices[v]->label, g->vertices[v]->d / (double)RAND_MAX, g->vertices[v]->lowPoint / (double)RAND_MAX);
	}
	for (int v=0; v<g->n; ++v) {
		for (struct VertexList* e=g->vertices[v]->neighborhood; e!=NULL; e=e->next) {
			if (e->startPoint->number < e->endPoint->number) {
				fprintf(out, "%i -- %i;\n", e->startPoint->number, e->endPoint->number);
			}
		}
	}
	fprintf(out, "}\n");
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq 0x20(%rsp), %rax
movl 0x8(%rax), %edx
leaq 0xb016(%rip), %rsi      # 0x353f8
movb $0x0, %al
callq 0x1140
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x2a484
movq 0x18(%rsp), %rdi
movl 0x14(%rsp), %edx
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq (%rax), %rcx
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x14(%rsp), %rsi
movq (%rax,%rsi,8), %rax
cvtsi2sdl 0x28(%rax), %xmm0
movsd 0xba69(%rip), %xmm1     # 0x35ea8
divsd %xmm1, %xmm0
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x14(%rsp), %rsi
movq (%rax,%rsi,8), %rax
cvtsi2sdl 0x20(%rax), %xmm1
movsd 0xba46(%rip), %xmm2     # 0x35ea8
divsd %xmm2, %xmm1
leaq 0xba6b(%rip), %rsi      # 0x35ed8
movb $0x2, %al
callq 0x1140
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x2a3f1
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
movq 0x20(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x2a529
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x2a517
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movl 0x18(%rax), %eax
movq 0x8(%rsp), %rcx
movq 0x18(%rcx), %rcx
cmpl 0x18(%rcx), %eax
jge 0x2a505
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rax
movq 0x10(%rax), %rax
movl 0x18(%rax), %edx
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movl 0x18(%rax), %ecx
leaq 0xba10(%rip), %rsi      # 0x35f0e
movb $0x0, %al
callq 0x1140
jmp 0x2a507
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x2a4b8
jmp 0x2a519
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x2a48c
movq 0x18(%rsp), %rdi
leaq 0xaee5(%rip), %rsi      # 0x3541a
movb $0x0, %al
callq 0x1140
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/randomGraphGenerators.c
// Function: randomOverlapGraph
struct Graph* randomOverlapGraph(int n, double d, struct GraphPool* gp) {
	struct Graph* g = createGraph(n, gp);

	// every vertex is a two-dimensional point
	for (int v=0; v<n; ++v) {
		g->vertices[v]->d = rand();
		g->vertices[v]->lowPoint = rand();
		g->vertices[v]->label = intLabel(1);
	}
	// add edge iff distance is smaller than d
	for (int v=0; v<n; ++v) {
		for (int w=v+1; w<n; ++w) {
			if (euclideanDistanceWrap(v, w, g) < d) {
				addEdgeBetweenVertices(v, w, intLabel(1), g, gp);
			}
		}
	}
	return g;
}

// Assembly:
subq $0x38, %rsp
movl %edi, 0x34(%rsp)
movsd %xmm0, 0x28(%rsp)
movq %rsi, 0x20(%rsp)
movl 0x34(%rsp), %edi
movq 0x20(%rsp), %rsi
callq 0xb850
movq %rax, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x34(%rsp), %eax
jge 0x2a5ef
callq 0x1220
movl %eax, %ecx
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x14(%rsp), %rdx
movq (%rax,%rdx,8), %rax
movl %ecx, 0x28(%rax)
callq 0x1220
movl %eax, %ecx
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x14(%rsp), %rdx
movq (%rax,%rdx,8), %rax
movl %ecx, 0x20(%rax)
movl $0x1, %edi
callq 0x14ae0
movq %rax, %rcx
movq 0x18(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x14(%rsp), %rdx
movq (%rax,%rdx,8), %rax
movq %rcx, (%rax)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x2a57e
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
cmpl 0x34(%rsp), %eax
jge 0x2a690
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x34(%rsp), %eax
jge 0x2a67e
movl 0x10(%rsp), %edi
movl 0xc(%rsp), %esi
movq 0x18(%rsp), %rdx
callq 0x2a350
movaps %xmm0, %xmm1
movsd 0x28(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x2a66f
movl 0x10(%rsp), %eax
movl %eax, 0x4(%rsp)
movl 0xc(%rsp), %eax
movl %eax, 0x8(%rsp)
movl $0x1, %edi
callq 0x14ae0
movl 0x4(%rsp), %edi
movl 0x8(%rsp), %esi
movq %rax, %rdx
movq 0x18(%rsp), %rcx
movq 0x20(%rsp), %r8
callq 0xb670
jmp 0x2a671
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x2a610
jmp 0x2a680
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x2a5f7
movq 0x18(%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/randomGraphGenerators.c
// Function: randomOverlapGraphWithLabels
struct Graph* randomOverlapGraphWithLabels(int n, double d, int nVertexLabels, struct GraphPool* gp) {
	struct Graph* g = createGraph(n, gp);

	// every vertex is a two-dimensional point
	for (int v=0; v<n; ++v) {
		g->vertices[v]->d = rand();
		g->vertices[v]->lowPoint = rand();
		g->vertices[v]->label = intLabel(rand() % nVertexLabels);
	}
	// add edge iff distance is smaller than d
	for (int v=0; v<n; ++v) {
		for (int w=v+1; w<n; ++w) {
			if (euclideanDistanceWrap(v, w, g) < d) {
				addEdgeBetweenVertices(v, w, intLabel(1), g, gp);
			}
		}
	}
	return g;
}

// Assembly:
subq $0x48, %rsp
movl %edi, 0x44(%rsp)
movsd %xmm0, 0x38(%rsp)
movl %esi, 0x34(%rsp)
movq %rdx, 0x28(%rsp)
movl 0x44(%rsp), %edi
movq 0x28(%rsp), %rsi
callq 0xb850
movq %rax, 0x20(%rsp)
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x44(%rsp), %eax
jge 0x2a74a
callq 0x1220
movl %eax, %ecx
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x1c(%rsp), %rdx
movq (%rax,%rdx,8), %rax
movl %ecx, 0x28(%rax)
callq 0x1220
movl %eax, %ecx
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x1c(%rsp), %rdx
movq (%rax,%rdx,8), %rax
movl %ecx, 0x20(%rax)
callq 0x1220
cltd
idivl 0x34(%rsp)
movl %edx, %edi
callq 0x14ae0
movq %rax, %rcx
movq 0x20(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x1c(%rsp), %rdx
movq (%rax,%rdx,8), %rax
movq %rcx, (%rax)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x2a6d2
movl $0x0, 0x18(%rsp)
movl 0x18(%rsp), %eax
cmpl 0x44(%rsp), %eax
jge 0x2a7eb
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x44(%rsp), %eax
jge 0x2a7d9
movl 0x18(%rsp), %edi
movl 0x14(%rsp), %esi
movq 0x20(%rsp), %rdx
callq 0x2a350
movaps %xmm0, %xmm1
movsd 0x38(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x2a7ca
movl 0x18(%rsp), %eax
movl %eax, 0xc(%rsp)
movl 0x14(%rsp), %eax
movl %eax, 0x10(%rsp)
movl $0x1, %edi
callq 0x14ae0
movl 0xc(%rsp), %edi
movl 0x10(%rsp), %esi
movq %rax, %rdx
movq 0x20(%rsp), %rcx
movq 0x28(%rsp), %r8
callq 0xb670
jmp 0x2a7cc
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x2a76b
jmp 0x2a7db
movl 0x18(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x18(%rsp)
jmp 0x2a752
movq 0x20(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/randomGraphGenerators.c
// Function: moveVertexGaussian
void moveVertexGaussian(struct Vertex* v, double moveParameter) {
	generateIntegerGaussianNoise(&(v->d), &(v->lowPoint), moveParameter);
	// mirror in unit interval
	// stupid undefined behavior of abs(INT_MIN) requires to do it ourselves:
	int a = v->d;
	int b = v->lowPoint;
	v->d = a == INT_MIN ? RAND_MAX : abs(a);
	v->lowPoint = b == INT_MIN ? RAND_MAX : abs(b);
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movsd %xmm0, 0x18(%rsp)
movq 0x20(%rsp), %rdi
addq $0x28, %rdi
movq 0x20(%rsp), %rsi
addq $0x20, %rsi
movsd 0x18(%rsp), %xmm0
callq 0x293f0
movq 0x20(%rsp), %rax
movl 0x28(%rax), %eax
movl %eax, 0x14(%rsp)
movq 0x20(%rsp), %rax
movl 0x20(%rax), %eax
movl %eax, 0x10(%rsp)
cmpl $0x80000000, 0x14(%rsp) # imm = 0x80000000
jne 0x2a859
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movl %eax, 0xc(%rsp)
jmp 0x2a868
movl 0x14(%rsp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movl %eax, 0xc(%rsp)
movl 0xc(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x28(%rax)
cmpl $0x80000000, 0x10(%rsp) # imm = 0x80000000
jne 0x2a889
movl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
movl %eax, 0x8(%rsp)
jmp 0x2a898
movl 0x10(%rsp), %eax
movl %eax, %ecx
negl %ecx
cmovnsl %ecx, %eax
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %ecx
movq 0x20(%rsp), %rax
movl %ecx, 0x20(%rax)
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/randomGraphGenerators.c
// Function: moveOverlapGraph
void moveOverlapGraph(struct Graph* g, double moveParameter, double d, struct GraphPool* gp) {

	// move vertices
	for (int v=0; v<g->n; ++v) {
		moveVertexGaussian(g->vertices[v], moveParameter);
	}

	// dump edges
	for (int v=0; v<g->n; ++v) {
		dumpVertexListRecursively(gp->listPool, g->vertices[v]->neighborhood);
		g->vertices[v]->neighborhood = NULL;
	}
	g->m = 0;

	// add edge iff distance is smaller than d
	for (int v=0; v<g->n; ++v) {
		for (int w=v+1; w<g->n; ++w) {
			if (euclideanDistanceWrap(v, w, g) < d) {
				addEdgeBetweenVertices(v, w, intLabel(1), g, gp);
				g->vertices[v]->neighborhood->isStringMaster = 1;
			}
		}
	}
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movsd %xmm0, 0x28(%rsp)
movsd %xmm1, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq 0x30(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x2ac39
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x14(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movsd 0x28(%rsp), %xmm0
callq 0x2a800
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x2ac02
movl $0x0, 0x10(%rsp)
movl 0x10(%rsp), %eax
movq 0x30(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x2ac99
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rdi
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rsi
callq 0x1f460
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq $0x0, 0x8(%rax)
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
jmp 0x2ac41
movq 0x30(%rsp), %rax
movl $0x0, 0x4(%rax)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x30(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x2ad6e
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
movl 0x8(%rsp), %eax
movq 0x30(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x2ad5c
movl 0xc(%rsp), %edi
movl 0x8(%rsp), %esi
movq 0x30(%rsp), %rdx
callq 0x2a350
movaps %xmm0, %xmm1
movsd 0x20(%rsp), %xmm0
ucomisd %xmm1, %xmm0
jbe 0x2ad4a
movl 0xc(%rsp), %eax
movl %eax, (%rsp)
movl 0x8(%rsp), %eax
movl %eax, 0x4(%rsp)
movl $0x1, %edi
callq 0x14ae0
movl (%rsp), %edi
movl 0x4(%rsp), %esi
movq %rax, %rdx
movq 0x30(%rsp), %rcx
movq 0x18(%rsp), %r8
callq 0xb670
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rax
movl $0x1, 0x28(%rax)
jmp 0x2ad4c
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x2acc9
jmp 0x2ad5e
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x2acad
addq $0x38, %rsp
retq
nopw %cs:(%rax,%rax)
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/sampleSubtrees.c
// Function: sampleSpanningTreeEdgesFromCactus
struct ShallowGraph* sampleSpanningTreeEdgesFromCactus(struct ShallowGraph* biconnectedComponents, struct ShallowGraphPool* sgp) {
	struct ShallowGraph* spanningTree = getShallowGraph(sgp);
	struct ShallowGraph* idx;
	for (idx=biconnectedComponents; idx!=NULL; idx=idx->next) {
		if (idx->m == 1) {
			appendEdge(spanningTree, shallowCopyEdge(idx->edges, sgp->listPool));
		} else {
			int removalEdgeId = rand() % idx->m;
			struct VertexList* e;
			int i = 0;
			for (e=idx->edges; e!=NULL; e=e->next) {
				if (i != removalEdgeId) {
					appendEdge(spanningTree, shallowCopyEdge(e, sgp->listPool));
				}
				++i;
			}
		}
	}
	return spanningTree;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq 0x38(%rsp), %rdi
callq 0x1fe70
movq %rax, 0x30(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x2ae80
movq 0x28(%rsp), %rax
cmpl $0x1, 0x10(%rax)
jne 0x2aded
movq 0x30(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rdi
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0xa310
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0xbf70
jmp 0x2ae6b
callq 0x1220
movq 0x28(%rsp), %rcx
cltd
idivl 0x10(%rcx)
movl %edx, 0x24(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x28(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x2ae69
movl 0x14(%rsp), %eax
cmpl 0x24(%rsp), %eax
je 0x2ae4e
movq 0x30(%rsp), %rax
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0xa310
movq (%rsp), %rdi
movq %rax, %rsi
callq 0xbf70
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x18(%rsp)
jmp 0x2ae14
jmp 0x2ae6b
jmp 0x2ae6d
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x28(%rsp)
jmp 0x2ada7
movq 0x30(%rsp), %rax
addq $0x48, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/sampleSubtrees.c
// Function: sampleSpanningTreeFromCactus
struct Graph* sampleSpanningTreeFromCactus(struct Graph* original, struct ShallowGraph* biconnectedComponents, struct GraphPool* gp) {
	struct Graph* spanningTree = emptyGraph(original, gp);
	struct ShallowGraph* idx;
	for (idx=biconnectedComponents; idx!=NULL; idx=idx->next) {
		if (idx->m == 1) {
			addEdgeBetweenVertices(idx->edges->startPoint->number, idx->edges->endPoint->number, idx->edges->label, spanningTree, gp);
		} else {
			int removalEdgeId = rand() % idx->m;
			struct VertexList* e;
			int i = 0;
			for (e=idx->edges; e!=NULL; e=e->next) {
				if (i != removalEdgeId) {
					addEdgeBetweenVertices(e->startPoint->number, e->endPoint->number, e->label, spanningTree, gp);
				}
				++i;
			}
		}
	}
	return spanningTree;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x40(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0xb7c0
movq %rax, 0x28(%rsp)
movq 0x38(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x2afaf
movq 0x20(%rsp), %rax
cmpl $0x1, 0x10(%rax)
jne 0x2af15
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movl 0x18(%rax), %edi
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq 0x18(%rax), %rax
movl 0x18(%rax), %esi
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq (%rax), %rdx
movq 0x28(%rsp), %rcx
movq 0x30(%rsp), %r8
callq 0xb670
jmp 0x2af9a
callq 0x1220
movq 0x20(%rsp), %rcx
cltd
idivl 0x10(%rcx)
movl %edx, 0x1c(%rsp)
movl $0x0, 0xc(%rsp)
movq 0x20(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x2af98
movl 0xc(%rsp), %eax
cmpl 0x1c(%rsp), %eax
je 0x2af7d
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movl 0x18(%rax), %edi
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movl 0x18(%rax), %esi
movq 0x10(%rsp), %rax
movq (%rax), %rdx
movq 0x28(%rsp), %rcx
movq 0x30(%rsp), %r8
callq 0xb670
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x10(%rsp)
jmp 0x2af3c
jmp 0x2af9a
jmp 0x2af9c
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x2aec1
movq 0x28(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/sampleSubtrees.c
// Function: sampleSpanningTreesUsingWilson
struct ShallowGraph* sampleSpanningTreesUsingWilson(struct Graph* g, int k, struct ShallowGraphPool* sgp) {
	struct ShallowGraph* spanningTrees = NULL;
	int j;
	for (j=0; j<k; ++j) {
		struct ShallowGraph* spanningTree = randomSpanningTreeAsShallowGraph(g, sgp);
		spanningTree->next = spanningTrees;
		spanningTrees = spanningTree;
	}
	return spanningTrees;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq %rdx, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jge 0x2b026
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x32f00
movq %rax, 0x8(%rsp)
movq 0x18(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x18(%rsp)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x2afe3
movq 0x18(%rsp), %rax
addq $0x38, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/sampleSubtrees.c
// Function: shuffle
void shuffle(struct VertexList** array, size_t n) {
    // struct timeval tv;
    // gettimeofday(&tv, NULL);
    // int usec = tv.tv_usec;
    // srand48(usec);

    if (n > 1) {
        size_t i;
        for (i = n - 1; i > 0; i--) {
            size_t j = (unsigned int) (rand() % i);
            struct VertexList* t = array[j];
            array[j] = array[i];
            array[i] = t;
        }
    }
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
cmpq $0x1, 0x18(%rsp)
jbe 0x2b14b
movq 0x18(%rsp), %rax
subq $0x1, %rax
movq %rax, 0x10(%rsp)
cmpq $0x0, 0x10(%rsp)
jbe 0x2b149
callq 0x1220
cltq
xorl %ecx, %ecx
movl %ecx, %edx
divq 0x10(%rsp)
movl %edx, %eax
movl %eax, %eax
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rax
movq 0x10(%rsp), %rcx
movq (%rax,%rcx,8), %rdx
movq 0x20(%rsp), %rax
movq 0x8(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq (%rsp), %rdx
movq 0x20(%rsp), %rax
movq 0x10(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movq 0x10(%rsp), %rax
addq $-0x1, %rax
movq %rax, 0x10(%rsp)
jmp 0x2b0d8
jmp 0x2b14b
addq $0x28, %rsp
retq
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/sampleSubtrees.c
// Function: sampleSpanningTreesUsingKruskalOnce
struct ShallowGraph* sampleSpanningTreesUsingKruskalOnce(struct Graph* g, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	struct ShallowGraph* spanningTree = NULL;
	int i;

	// create and shuffle array of edges of g
	struct ShallowGraph* edges = getGraphEdges(g, sgp);
	struct VertexList** edgeArray = malloc(g->m * sizeof(struct VertexList*));
	if (edges->m != 0) {
		edgeArray[0] = edges->edges;
	}
	for (i=1; i < g->m; ++i) {
		edgeArray[i] = edgeArray[i-1]->next;
	}
	shuffle(edgeArray, g->m);

	// do the kruskal
	spanningTree = kruskalMST(g, edgeArray, gp, sgp);

	// garbage collection
	dumpShallowGraphCycle(sgp, edges);
	free(edgeArray);

	return spanningTree;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq $0x0, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xb530
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rax
movslq 0x4(%rax), %rdi
shlq $0x3, %rdi
callq 0x1170
movq %rax, (%rsp)
movq 0x8(%rsp), %rax
cmpl $0x0, 0x10(%rax)
je 0x2b1b0
movq 0x8(%rsp), %rax
movq (%rax), %rcx
movq (%rsp), %rax
movq %rcx, (%rax)
movl $0x1, 0x14(%rsp)
movl 0x14(%rsp), %eax
movq 0x30(%rsp), %rcx
cmpl 0x4(%rcx), %eax
jge 0x2b1f6
movq (%rsp), %rax
movl 0x14(%rsp), %ecx
subl $0x1, %ecx
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq 0x8(%rax), %rdx
movq (%rsp), %rax
movslq 0x14(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x2b1b8
movq (%rsp), %rdi
movq 0x30(%rsp), %rax
movslq 0x4(%rax), %rsi
callq 0x2b0b0
movq 0x30(%rsp), %rdi
movq (%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %rcx
callq 0x100a0
movq %rax, 0x18(%rsp)
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x20000
movq (%rsp), %rdi
callq 0x1030
movq 0x18(%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/sampleSubtrees.c
// Function: sampleSpanningTreesUsingKruskal
struct ShallowGraph* sampleSpanningTreesUsingKruskal(struct Graph* g, int k, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	struct ShallowGraph* spanningTrees = NULL;
	int i;

	for (i=0; i<k; ++i) {
		struct ShallowGraph* tmp = sampleSpanningTreesUsingKruskalOnce(g, gp, sgp);
		tmp->next = spanningTrees;
		spanningTrees = tmp;
	}
	return spanningTrees;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
cmpl 0x2c(%rsp), %eax
jge 0x2b2fd
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x2b150
movq %rax, (%rsp)
movq 0x10(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x18(%rax)
movq (%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x2b2b8
movq 0x10(%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/sampleSubtrees.c
// Function: sampleSpanningTreesUsingListing
struct ShallowGraph* sampleSpanningTreesUsingListing(struct Graph* g, int k, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	struct ShallowGraph* spanningTrees = NULL;
	struct ShallowGraph* trees = listSpanningTrees(g, sgp, gp);
	struct ShallowGraph** array;
	
	struct ShallowGraph* idx;
	int j;
	int nTrees = 0;

	/* find number of listed trees, put them in array */
	for (idx=trees; idx; idx=idx->next) ++nTrees;

	array = malloc(nTrees * sizeof(struct ShallowGraph*));
	j = 0;
	for (idx=trees; idx; idx=idx->next) {	
		array[j] = idx;
		++j;
	}

	/* sample k trees uniformly at random */
	for (j=0; j<k; ++j) {
		int rnd = rand() % nTrees;
		// can't just use the listed tree itself, as it might get selected more than once
		struct ShallowGraph* tree = cloneShallowGraph(array[rnd], sgp);
		tree->next = spanningTrees;
		spanningTrees = tree;
	}
	dumpShallowGraphCycle(sgp, trees);
	free(array);
	return spanningTrees;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x50(%rsp)
movl %esi, 0x4c(%rsp)
movq %rdx, 0x40(%rsp)
movq %rcx, 0x38(%rsp)
movq $0x0, 0x30(%rsp)
movq 0x50(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x40(%rsp), %rdx
callq 0x12d20
movq %rax, 0x28(%rsp)
movl $0x0, 0x10(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x2b3be
movl 0x10(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x10(%rsp)
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
jmp 0x2b39b
movslq 0x10(%rsp), %rdi
shlq $0x3, %rdi
callq 0x1170
movq %rax, 0x20(%rsp)
movl $0x0, 0x14(%rsp)
movq 0x28(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x2b419
movq 0x18(%rsp), %rdx
movq 0x20(%rsp), %rax
movslq 0x14(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
jmp 0x2b3e3
movl $0x0, 0x14(%rsp)
movl 0x14(%rsp), %eax
cmpl 0x4c(%rsp), %eax
jge 0x2b478
callq 0x1220
cltd
idivl 0x10(%rsp)
movl %edx, 0xc(%rsp)
movq 0x20(%rsp), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x38(%rsp), %rsi
callq 0xbe10
movq %rax, (%rsp)
movq 0x30(%rsp), %rcx
movq (%rsp), %rax
movq %rcx, 0x18(%rax)
movq (%rsp), %rax
movq %rax, 0x30(%rsp)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x2b421
movq 0x38(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0x20000
movq 0x20(%rsp), %rdi
callq 0x1030
movq 0x30(%rsp), %rax
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/sampleSubtrees.c
// Function: sampleSpanningTreesUsingMix
struct ShallowGraph* sampleSpanningTreesUsingMix(struct Graph* g, int k, long int threshold, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	long upperBound = getGoodEstimate(g, sgp, gp);
	if ((upperBound < threshold) && (upperBound != -1)) {
		return sampleSpanningTreesUsingListing(g, k, gp, sgp);
	} else {
		return sampleSpanningTreesUsingWilson(g, k, sgp);
	}
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x28(%rsp)
movl %esi, 0x24(%rsp)
movq %rdx, 0x18(%rsp)
movq %rcx, 0x10(%rsp)
movq %r8, 0x8(%rsp)
movq 0x28(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x10(%rsp), %rdx
callq 0x32580
movq %rax, (%rsp)
movq (%rsp), %rax
cmpq 0x18(%rsp), %rax
jge 0x2b545
cmpq $-0x1, (%rsp)
je 0x2b545
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movq 0x10(%rsp), %rdx
movq 0x8(%rsp), %rcx
callq 0x2b350
movq %rax, 0x30(%rsp)
jmp 0x2b55d
movq 0x28(%rsp), %rdi
movl 0x24(%rsp), %esi
movq 0x8(%rsp), %rdx
callq 0x2afc0
movq %rax, 0x30(%rsp)
movq 0x30(%rsp), %rax
addq $0x38, %rsp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/sampleSubtrees.c
// Function: sampleSpanningTreesUsingPartialListingMix
struct ShallowGraph* sampleSpanningTreesUsingPartialListingMix(struct Graph* g, int k, long int threshold, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	long upperBound = getGoodEstimate(g, sgp, gp);

	if (k != 1) {
		fprintf(stderr, "This method will only sample one spanning tree, you asked for %i\n", k);
		k = 1;
	}
	if ((upperBound < threshold) && (upperBound != -1)) {
		int i = rand() % threshold;
		int storeI = i;
		struct ShallowGraph* garbage = listKSpanningTrees(g, &i, sgp, gp);
		if (i == 0) {
			struct ShallowGraph* result = garbage->prev;
			result->prev->next=garbage;
			dumpShallowGraphCycle(sgp, garbage);
			return result;
		} else {
			// TODO: do something sensible
			struct ShallowGraph* result = garbage->prev;
			result->prev->next=garbage;
			dumpShallowGraphCycle(sgp, garbage);
			fprintf(stderr, "oversampled! i=%i leftover=%i\n", i, storeI);
			return result;
		}
	} else {
		return sampleSpanningTreesUsingWilson(g, k, sgp);
	}
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movl %esi, 0x44(%rsp)
movq %rdx, 0x38(%rsp)
movq %rcx, 0x30(%rsp)
movq %r8, 0x28(%rsp)
movq 0x48(%rsp), %rdi
movq 0x28(%rsp), %rsi
movq 0x30(%rsp), %rdx
callq 0x32580
movq %rax, 0x20(%rsp)
cmpl $0x1, 0x44(%rsp)
je 0x2b610
movq 0x12a05(%rip), %rax     # 0x3dff8
movq (%rax), %rdi
movl 0x44(%rsp), %edx
leaq 0xa99e(%rip), %rsi      # 0x35f9f
movb $0x0, %al
callq 0x1140
movl $0x1, 0x44(%rsp)
movq 0x20(%rsp), %rax
cmpq 0x38(%rsp), %rax
jge 0x2b700
cmpq $-0x1, 0x20(%rsp)
je 0x2b700
callq 0x1220
cltq
cqto
idivq 0x38(%rsp)
movl %edx, %eax
movl %eax, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, 0x18(%rsp)
movq 0x48(%rsp), %rdi
movq 0x28(%rsp), %rdx
movq 0x30(%rsp), %rcx
leaq 0x1c(%rsp), %rsi
callq 0x131f0
movq %rax, 0x10(%rsp)
cmpl $0x0, 0x1c(%rsp)
jne 0x2b6a8
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, 0x8(%rsp)
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %rax
movq 0x20(%rax), %rax
movq %rcx, 0x18(%rax)
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x20000
movq 0x8(%rsp), %rax
movq %rax, 0x50(%rsp)
jmp 0x2b718
movq 0x10(%rsp), %rax
movq 0x20(%rax), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rcx
movq (%rsp), %rax
movq 0x20(%rax), %rax
movq %rcx, 0x18(%rax)
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x20000
movq 0x1291c(%rip), %rax     # 0x3dff8
movq (%rax), %rdi
movl 0x1c(%rsp), %edx
movl 0x18(%rsp), %ecx
leaq 0xa8f3(%rip), %rsi      # 0x35fe1
movb $0x0, %al
callq 0x1140
movq (%rsp), %rax
movq %rax, 0x50(%rsp)
jmp 0x2b718
movq 0x48(%rsp), %rdi
movl 0x44(%rsp), %esi
movq 0x28(%rsp), %rdx
callq 0x2afc0
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/sampleSubtrees.c
// Function: sampleSpanningTreesUsingCactusMix
struct ShallowGraph* sampleSpanningTreesUsingCactusMix(struct Graph* g, int k, long int threshold, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	struct ShallowGraph* spanningTrees = NULL;
	struct ShallowGraph* biconnectedComponents = listBiconnectedComponents(g, sgp);
	int blockCount = 0;
	struct ShallowGraph* idx;
	for (idx=biconnectedComponents; idx!=NULL; idx=idx->next) {
		if (idx->m > 1) {
			++blockCount;
		}
	}
	/* if g is a cactus graph */
	if (g->n - 1 + blockCount == g->m) {
		int j;
		for (j=0; j<k; ++j) {	
			struct ShallowGraph* spanningTree = sampleSpanningTreeEdgesFromCactus(biconnectedComponents, sgp);
			spanningTree->next = spanningTrees;
			spanningTrees = spanningTree;
		}
	} else {
		// for speedup. this is sampleSpanningTreesUsingMix
		long upperBound = getGoodEstimatePrecomputedBlocks(g, biconnectedComponents, sgp, gp);
		if ((upperBound < threshold) && (upperBound != -1)) {
			spanningTrees = sampleSpanningTreesUsingListing(g, k, gp, sgp);
		} else {
			spanningTrees = sampleSpanningTreesUsingWilson(g, k, sgp);
		}
	}
	dumpShallowGraphCycle(sgp, biconnectedComponents);
	return spanningTrees;
}

// Assembly:
subq $0x68, %rsp
movq %rdi, 0x60(%rsp)
movl %esi, 0x5c(%rsp)
movq %rdx, 0x50(%rsp)
movq %rcx, 0x48(%rsp)
movq %r8, 0x40(%rsp)
movq $0x0, 0x38(%rsp)
movq 0x60(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x10700
movq %rax, 0x30(%rsp)
movl $0x0, 0x2c(%rsp)
movq 0x30(%rsp), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x2b7eb
movq 0x20(%rsp), %rax
cmpl $0x1, 0x10(%rax)
jle 0x2b7d9
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x2b7db
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x2b7bb
movq 0x60(%rsp), %rax
movl (%rax), %eax
subl $0x1, %eax
addl 0x2c(%rsp), %eax
movq 0x60(%rsp), %rcx
cmpl 0x4(%rcx), %eax
jne 0x2b850
movl $0x0, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x5c(%rsp), %eax
jge 0x2b84e
movq 0x30(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0x2ad80
movq %rax, 0x10(%rsp)
movq 0x38(%rsp), %rcx
movq 0x10(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x10(%rsp), %rax
movq %rax, 0x38(%rsp)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x2b80b
jmp 0x2b8bb
movq 0x60(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x40(%rsp), %rdx
movq 0x48(%rsp), %rcx
callq 0x325e0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
cmpq 0x50(%rsp), %rax
jge 0x2b8a1
cmpq $-0x1, 0x8(%rsp)
je 0x2b8a1
movq 0x60(%rsp), %rdi
movl 0x5c(%rsp), %esi
movq 0x48(%rsp), %rdx
movq 0x40(%rsp), %rcx
callq 0x2b350
movq %rax, 0x38(%rsp)
jmp 0x2b8b9
movq 0x60(%rsp), %rdi
movl 0x5c(%rsp), %esi
movq 0x40(%rsp), %rdx
callq 0x2afc0
movq %rax, 0x38(%rsp)
jmp 0x2b8bb
movq 0x40(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x20000
movq 0x38(%rsp), %rax
addq $0x68, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/sampleSubtrees.c
// Function: listBridgeForest
struct ShallowGraph* listBridgeForest(struct Graph* g, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	/* find biconnected Components */
	struct ShallowGraph* h = listBiconnectedComponents(g, sgp);
	// TODO replace this by a method that just creates the forest without listing cycles
	struct Graph* forest = partitionIntoForestAndCycles(h, g, gp, sgp);
	struct ShallowGraph* bridgeTrees = getConnectedComponents(forest, sgp);
	struct ShallowGraph* tmp;
	// the resulting trees need to reference the original graph g
	for (tmp=bridgeTrees; tmp!=NULL; tmp=tmp->next) {
		rebaseShallowGraphs(tmp, g);
	}
	/* garbage collection */
	dumpGraphList(gp, forest);
	return bridgeTrees;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x10700
movq %rax, 0x18(%rsp)
movq 0x18(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rdx
movq 0x20(%rsp), %rcx
callq 0x10d30
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x5510
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x2b9a5
movq (%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0xbc00
movq (%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, (%rsp)
jmp 0x2b982
movq 0x28(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x1fc60
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/sampleSubtrees.c
// Function: listOrSampleSpanningTrees
struct ShallowGraph* listOrSampleSpanningTrees(struct Graph* g, int k, long int threshold, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	struct ShallowGraph* spanningTrees = NULL; 
	long upperBound = getGoodEstimate(g, sgp, gp);
	if ((upperBound < threshold) && (upperBound != -1)) {
		spanningTrees = listSpanningTrees(g, sgp, gp);	
	} else {
		spanningTrees = sampleSpanningTreesUsingWilson(g, k, sgp);
	}
	return spanningTrees;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movl %esi, 0x2c(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq %r8, 0x10(%rsp)
movq $0x0, 0x8(%rsp)
movq 0x30(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x32580
movq %rax, (%rsp)
movq (%rsp), %rax
cmpq 0x20(%rsp), %rax
jge 0x2ba6a
cmpq $-0x1, (%rsp)
je 0x2ba6a
movq 0x30(%rsp), %rdi
movq 0x10(%rsp), %rsi
movq 0x18(%rsp), %rdx
callq 0x12d20
movq %rax, 0x8(%rsp)
jmp 0x2ba82
movq 0x30(%rsp), %rdi
movl 0x2c(%rsp), %esi
movq 0x10(%rsp), %rdx
callq 0x2afc0
movq %rax, 0x8(%rsp)
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax)