LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/treeKernels.c
// Function: edgeSort
struct ShallowGraph* edgeSort(struct Vertex* v, int maxDepth, struct ShallowGraphPool* sgp) {
	struct VertexList* e;
	struct VertexList* f;
	struct VertexList* first = getVertexList(sgp->listPool);
	struct ShallowGraph* output = getShallowGraph(sgp);
	struct ShallowGraph* fifo = getShallowGraph(sgp);

	/* create artificial edge to start bfs */
	first->endPoint = v;
	first->startPoint = v;
	appendEdge(fifo, first);

	/* bfs */
	while((e = popEdge(fifo))) {

		/* breaking condition */
		if (e->startPoint->visited > maxDepth) {
			dumpVertexList(sgp->listPool, e);
			break;
		}

		/* store distance */
		e->endPoint->visited = e->startPoint->visited + 1;
		appendEdge(output, e);

		/* put children in fifo queue */
		for (f=e->endPoint->neighborhood; f; f = f->next) {
			if (f->endPoint->visited == 0) {
				appendEdge(fifo, shallowCopyEdge(f, sgp->listPool));
			}
		}
	}

	dumpShallowGraph(sgp, fifo);

	return output;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movq %rdx, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x1f310
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rdi
callq 0x1fe70
movq %rax, 0x10(%rsp)
movq 0x30(%rsp), %rdi
callq 0x1fe70
movq %rax, 0x8(%rsp)
movq 0x40(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x40(%rsp), %rcx
movq 0x18(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x8(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0xbf70
movq 0x8(%rsp), %rdi
callq 0xbef0
movq %rax, 0x28(%rsp)
cmpq $0x0, %rax
je 0x319b3
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
movl 0x1c(%rax), %eax
cmpl 0x3c(%rsp), %eax
jle 0x31921
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x28(%rsp), %rsi
callq 0x1f410
jmp 0x319b3
movq 0x28(%rsp), %rax
movq 0x10(%rax), %rax
movl 0x1c(%rax), %ecx
addl $0x1, %ecx
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rax
movl %ecx, 0x1c(%rax)
movq 0x10(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0xbf70
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x8(%rax), %rax
movq %rax, 0x20(%rsp)
cmpq $0x0, 0x20(%rsp)
je 0x319ae
movq 0x20(%rsp), %rax
movq 0x18(%rax), %rax
cmpl $0x0, 0x1c(%rax)
jne 0x3199c
movq 0x8(%rsp), %rax
movq %rax, (%rsp)
movq 0x20(%rsp), %rdi
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0xa310
movq (%rsp), %rdi
movq %rax, %rsi
callq 0xbf70
jmp 0x3199e
movq 0x20(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x20(%rsp)
jmp 0x3195d
jmp 0x318de
movq 0x30(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x1ff70
movq 0x10(%rsp), %rax
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/treeKernels.c
// Function: bfsSubtreeEnumeration
struct ShallowGraph* bfsSubtreeEnumeration(struct Graph* t, int maxDepth, struct ShallowGraphPool* sgp) {
	int i;
	struct ShallowGraph* results = NULL;

	for (i=0; i<t->n; ++i) {
		if (t->vertices[i]) {

			int j;
			struct ShallowGraph* sorted = edgeSort(t->vertices[i], maxDepth, sgp);

			/* if maxDepth is too large, the for loop below will return
			 * multiple copies of the largest level tree. */
			if (maxDepth > sorted->lastEdge->endPoint->visited) {
				maxDepth = sorted->lastEdge->endPoint->visited;
			}

			/* compute and store canonical string of the tree rooted at v for each level
			 * TODO This can change. Maybe compute canonical string for free tree... */
			for (j=1; j<=maxDepth; ++j) {
				struct ShallowGraph* level = canonicalStringOfRootedLevelTree(t->vertices[i], NULL, j, sgp);
				level->next = results;
				results = level;
			}

			cleanUpEdgeSort(t->vertices[i], sgp);
			dumpShallowGraph(sgp, sorted);
		}
	}
	return results;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movl %esi, 0x3c(%rsp)
movq %rdx, 0x30(%rsp)
movq $0x0, 0x20(%rsp)
movl $0x0, 0x2c(%rsp)
movl 0x2c(%rsp), %eax
movq 0x40(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x31b09
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x2c(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x31af7
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x2c(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movl 0x3c(%rsp), %esi
movq 0x30(%rsp), %rdx
callq 0x31870
movq %rax, 0x10(%rsp)
movl 0x3c(%rsp), %eax
movq 0x10(%rsp), %rcx
movq 0x8(%rcx), %rcx
movq 0x18(%rcx), %rcx
cmpl 0x1c(%rcx), %eax
jle 0x31a6c
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rax
movl 0x1c(%rax), %eax
movl %eax, 0x3c(%rsp)
movl $0x1, 0x1c(%rsp)
movl 0x1c(%rsp), %eax
cmpl 0x3c(%rsp), %eax
jg 0x31acc
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x2c(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movl 0x1c(%rsp), %edx
movq 0x30(%rsp), %rcx
xorl %eax, %eax
movl %eax, %esi
callq 0x97f0
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rcx
movq 0x8(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x8(%rsp), %rax
movq %rax, 0x20(%rsp)
movl 0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x1c(%rsp)
jmp 0x31a74
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x2c(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x30(%rsp), %rsi
callq 0x31750
movq 0x30(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x1ff70
jmp 0x31af9
movl 0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x2c(%rsp)
jmp 0x319f3
movq 0x20(%rsp), %rax
addq $0x48, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/treeKernels.c
// Function: fullSubtreeEnumeration
int fullSubtreeEnumeration(struct Graph* t, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	int numberOfTrees = 0;

	/* get initially empty list of forbidden edges and E(t) */
	struct ShallowGraph* allEdges = getGraphEdges(t, sgp);
	struct ShallowGraph* forbiddenEdges = getShallowGraph(sgp);

	/* create $ current = (V(t), \emptyset) $ */
	struct Graph* current = getGraph(gp);
	int i;
	setVertexNumber(current, t->n);
	for (i=0; i<t->n; ++i) {
		current->vertices[i] = shallowCopyVertex(t->vertices[i], gp->vertexPool);
	}

	recSubtreeEnum(current, forbiddenEdges, allEdges, &numberOfTrees, sgp);


	/* garbage collection */
	dumpShallowGraph(sgp, allEdges);
	dumpShallowGraph(sgp, forbiddenEdges);
	dumpGraph(gp, current);

	return numberOfTrees;
}

// Assembly:
subq $0x48, %rsp
movq %rdi, 0x40(%rsp)
movq %rsi, 0x38(%rsp)
movq %rdx, 0x30(%rsp)
movl $0x0, 0x2c(%rsp)
movq 0x40(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0xb530
movq %rax, 0x20(%rsp)
movq 0x30(%rsp), %rdi
callq 0x1fe70
movq %rax, 0x18(%rsp)
movq 0x38(%rsp), %rdi
callq 0x1fa40
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rdi
movq 0x40(%rsp), %rax
movl (%rax), %esi
callq 0xaa00
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x40(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x32085
movq 0x40(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x38(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0xa3f0
movq %rax, %rdx
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0xc(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x32036
movq 0x10(%rsp), %rdi
movq 0x18(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x30(%rsp), %r8
leaq 0x2c(%rsp), %rcx
callq 0x31c60
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x1ff70
movq 0x30(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x1ff70
movq 0x38(%rsp), %rdi
movq 0x10(%rsp), %rsi
callq 0x1fb30
movl 0x2c(%rsp), %eax
addq $0x48, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/upperBoundsForSpanningTrees.c
// Function: nCr
long nCr(long n, long r) {
	long numer = 1;
	long denom = 1;
	int i;
	if (n - r < r) {
		r = n - r;
	}
	if (r == 0) {
		return 1;
	}
	for (i=n; i>n-r; --i) {
		numer *= i;
	}
	for (i=1; i<r+1; ++i) {
		denom *= i;
	}
	return numer / denom;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq $0x1, -0x20(%rsp)
movq $0x1, -0x28(%rsp)
movq -0x10(%rsp), %rax
subq -0x18(%rsp), %rax
cmpq -0x18(%rsp), %rax
jge 0x3211c
movq -0x10(%rsp), %rax
subq -0x18(%rsp), %rax
movq %rax, -0x18(%rsp)
cmpq $0x0, -0x18(%rsp)
jne 0x32132
movq $0x1, -0x8(%rsp)
jmp 0x321b5
movq -0x10(%rsp), %rax
movl %eax, -0x2c(%rsp)
movslq -0x2c(%rsp), %rax
movq -0x10(%rsp), %rcx
subq -0x18(%rsp), %rcx
cmpq %rcx, %rax
jle 0x3216c
movslq -0x2c(%rsp), %rax
imulq -0x20(%rsp), %rax
movq %rax, -0x20(%rsp)
movl -0x2c(%rsp), %eax
addl $-0x1, %eax
movl %eax, -0x2c(%rsp)
jmp 0x3213b
movl $0x1, -0x2c(%rsp)
movslq -0x2c(%rsp), %rax
movq -0x18(%rsp), %rcx
addq $0x1, %rcx
cmpq %rcx, %rax
jge 0x321a4
movslq -0x2c(%rsp), %rax
imulq -0x28(%rsp), %rax
movq %rax, -0x28(%rsp)
movl -0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rsp)
jmp 0x32174
movq -0x20(%rsp), %rax
cqto
idivq -0x28(%rsp)
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/upperBoundsForSpanningTrees.c
// Function: nCr2
long nCr2(long n, long r) {
	long numer = 1;
	long denom = 1;
	int i;
	if (n - r < r) {
		r = n - r;
	}
	if (r == 0) {
		return 1;
	}
	for (i=n; i>n-r; --i) {
		/* avoid overflowing */
		if (numer >= LONG_MAX / i) {
			return -1;
		}
		numer *= i;
	}
	/* r! is always smaller than (n-r)*...*(r+1) */
	for (i=1; i<r+1; ++i) {
		denom *= i;
	}
	return numer / denom;
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq %rsi, -0x18(%rsp)
movq $0x1, -0x20(%rsp)
movq $0x1, -0x28(%rsp)
movq -0x10(%rsp), %rax
subq -0x18(%rsp), %rax
cmpq -0x18(%rsp), %rax
jge 0x321fc
movq -0x10(%rsp), %rax
subq -0x18(%rsp), %rax
movq %rax, -0x18(%rsp)
cmpq $0x0, -0x18(%rsp)
jne 0x32212
movq $0x1, -0x8(%rsp)
jmp 0x322cb
movq -0x10(%rsp), %rax
movl %eax, -0x2c(%rsp)
movslq -0x2c(%rsp), %rax
movq -0x10(%rsp), %rcx
subq -0x18(%rsp), %rcx
cmpq %rcx, %rax
jle 0x32282
movq -0x20(%rsp), %rax
movq %rax, -0x38(%rsp)
movslq -0x2c(%rsp), %rcx
movabsq $0x7fffffffffffffff, %rax # imm = 0x7FFFFFFFFFFFFFFF
cqto
idivq %rcx
movq %rax, %rcx
movq -0x38(%rsp), %rax
cmpq %rcx, %rax
jl 0x32265
movq $-0x1, -0x8(%rsp)
jmp 0x322cb
movslq -0x2c(%rsp), %rax
imulq -0x20(%rsp), %rax
movq %rax, -0x20(%rsp)
movl -0x2c(%rsp), %eax
addl $-0x1, %eax
movl %eax, -0x2c(%rsp)
jmp 0x3221b
movl $0x1, -0x2c(%rsp)
movslq -0x2c(%rsp), %rax
movq -0x18(%rsp), %rcx
addq $0x1, %rcx
cmpq %rcx, %rax
jge 0x322ba
movslq -0x2c(%rsp), %rax
imulq -0x28(%rsp), %rax
movq %rax, -0x28(%rsp)
movl -0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rsp)
jmp 0x3228a
movq -0x20(%rsp), %rax
cqto
idivq -0x28(%rsp)
movq %rax, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/upperBoundsForSpanningTrees.c
// Function: outerplanarBound
long outerplanarBound(long m, long n) {
	double estimate = 0.0;
	long i;
	long k = m-n;
	for (i=0; i<k+1; ++i) {
		double mean = n / (double)(i+1);
		double meanPot = 1.0;
		int j;
		long bin;

		for (j=0; j<i+1; ++j) {
			meanPot *= mean;
		}

		if (meanPot >= DBL_MAX) {
			return (long)-1;
		}
		
		bin = nCr2(k, i);
		if (bin < 0) {
			/* there was an overflow in nCr2 */
			return (long)-1;
		} else {
			estimate += bin * meanPot;
		}
	}
	if (estimate > LONG_MAX) {
		return (unsigned long)-1;
	} else {
		return (unsigned long)estimate;
	}
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
xorps %xmm0, %xmm0
movsd %xmm0, 0x38(%rsp)
movq 0x48(%rsp), %rax
subq 0x40(%rsp), %rax
movq %rax, 0x28(%rsp)
movq $0x0, 0x30(%rsp)
movq 0x30(%rsp), %rax
movq 0x28(%rsp), %rcx
addq $0x1, %rcx
cmpq %rcx, %rax
jge 0x3243f
cvtsi2sdq 0x40(%rsp), %xmm0
movq 0x30(%rsp), %rax
addq $0x1, %rax
cvtsi2sd %rax, %xmm1
divsd %xmm1, %xmm0
movsd %xmm0, 0x20(%rsp)
movsd 0x3a13(%rip), %xmm0     # 0x35d90
movsd %xmm0, 0x18(%rsp)
movl $0x0, 0x14(%rsp)
movslq 0x14(%rsp), %rax
movq 0x30(%rsp), %rcx
addq $0x1, %rcx
cmpq %rcx, %rax
jge 0x323bd
movsd 0x20(%rsp), %xmm0
mulsd 0x18(%rsp), %xmm0
movsd %xmm0, 0x18(%rsp)
movl 0x14(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x14(%rsp)
jmp 0x3238b
movsd 0x18(%rsp), %xmm0
movsd 0x3d35(%rip), %xmm1     # 0x36100
ucomisd %xmm1, %xmm0
jb 0x323df
movq $-0x1, 0x50(%rsp)
jmp 0x3248f
movq 0x28(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x321c0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
jge 0x32409
movq $-0x1, 0x50(%rsp)
jmp 0x3248f
cvtsi2sdq 0x8(%rsp), %xmm0
movsd 0x18(%rsp), %xmm2
movsd 0x38(%rsp), %xmm1
mulsd %xmm2, %xmm0
addsd %xmm1, %xmm0
movsd %xmm0, 0x38(%rsp)
jmp 0x3242c
movq 0x30(%rsp), %rax
addq $0x1, %rax
movq %rax, 0x30(%rsp)
jmp 0x3233f
movsd 0x38(%rsp), %xmm0
movsd 0x3cab(%rip), %xmm1     # 0x360f8
ucomisd %xmm1, %xmm0
jbe 0x3245e
movq $-0x1, 0x50(%rsp)
jmp 0x3248f
movsd 0x38(%rsp), %xmm0
movsd 0x3c8c(%rip), %xmm2     # 0x360f8
movaps %xmm0, %xmm1
subsd %xmm2, %xmm1
cvttsd2si %xmm1, %rcx
cvttsd2si %xmm0, %rax
movq %rax, %rdx
sarq $0x3f, %rdx
andq %rdx, %rcx
orq %rcx, %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/upperBoundsForSpanningTrees.c
// Function: getVertexNumberOfInducedGraph
int getVertexNumberOfInducedGraph(struct ShallowGraph* g, int n, int* vertices) {
	int i;
	struct VertexList* e;
	int nInd = 0;
	for(i=0; i<n; ++i) { vertices[i] = 0; }
	for(e=g->edges; e!=NULL; e=e->next) {
		vertices[e->startPoint->number] = 1;
		vertices[e->endPoint->number] = 1;
	}
	for (i=0; i<n; ++i) {
		if (vertices[i] != 0) {
			++nInd;
		}
	}
	return nInd;
}

// Assembly:
movq %rdi, -0x8(%rsp)
movl %esi, -0xc(%rsp)
movq %rdx, -0x18(%rsp)
movl $0x0, -0x2c(%rsp)
movl $0x0, -0x1c(%rsp)
movl -0x1c(%rsp), %eax
cmpl -0xc(%rsp), %eax
jge 0x324e6
movq -0x18(%rsp), %rax
movslq -0x1c(%rsp), %rcx
movl $0x0, (%rax,%rcx,4)
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0x324be
movq -0x8(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x28(%rsp)
cmpq $0x0, -0x28(%rsp)
je 0x3253d
movq -0x18(%rsp), %rax
movq -0x28(%rsp), %rcx
movq 0x10(%rcx), %rcx
movslq 0x18(%rcx), %rcx
movl $0x1, (%rax,%rcx,4)
movq -0x18(%rsp), %rax
movq -0x28(%rsp), %rcx
movq 0x18(%rcx), %rcx
movslq 0x18(%rcx), %rcx
movl $0x1, (%rax,%rcx,4)
movq -0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, -0x28(%rsp)
jmp 0x324f3
movl $0x0, -0x1c(%rsp)
movl -0x1c(%rsp), %eax
cmpl -0xc(%rsp), %eax
jge 0x32579
movq -0x18(%rsp), %rax
movslq -0x1c(%rsp), %rcx
cmpl $0x0, (%rax,%rcx,4)
je 0x3256a
movl -0x2c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rsp)
jmp 0x3256c
movl -0x1c(%rsp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rsp)
jmp 0x32545
movl -0x2c(%rsp), %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/upperBoundsForSpanningTrees.c
// Function: getGoodEstimate
long int getGoodEstimate(struct Graph* g, struct ShallowGraphPool* sgp, struct GraphPool* gp) {
	struct ShallowGraph* biconnectedComponents = listBiconnectedComponents(g, sgp);
	long int estimate = getGoodEstimatePrecomputedBlocks(g, biconnectedComponents, sgp, gp);
	dumpShallowGraphCycle(sgp, biconnectedComponents);
	return estimate;
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x20(%rsp)
movq %rsi, 0x18(%rsp)
movq %rdx, 0x10(%rsp)
movq 0x20(%rsp), %rdi
movq 0x18(%rsp), %rsi
callq 0x10700
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rdi
movq 0x8(%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
callq 0x325e0
movq %rax, (%rsp)
movq 0x18(%rsp), %rdi
movq 0x8(%rsp), %rsi
callq 0x20000
movq (%rsp), %rax
addq $0x28, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/upperBoundsForSpanningTrees.c
// Function: getGoodEstimatePrecomputedBlocks
long int getGoodEstimatePrecomputedBlocks(struct Graph* g, struct ShallowGraph* biconnectedComponents, struct ShallowGraphPool* sgp, struct GraphPool* gp) {
	struct ShallowGraph* idx;
	long estimate = 1;
	int* vertices = malloc(g->n * sizeof(int));

	for (idx=biconnectedComponents; idx!=NULL; idx=idx->next) {
		if (idx->m != 1) {
			int nInd = getVertexNumberOfInducedGraph(idx, g->n, vertices);
			if (!isOuterplanarBlockShallow(idx, sgp, gp)) {
				long bound = trivialBound(idx->m, nInd);
				if (bound == -1){
					free(vertices);
					return -1;
				} else {
					estimate *= bound;
				}
			} else {
				long bound = outerplanarBound(idx->m, nInd);
				if (bound == -1) {
					free(vertices);
					return -1;
				} else {
					estimate *= bound;
				}
			}
		} else {
			/* Biconnected Component idx is a bridge. Computation would be:
			estimate *= 1;
			However, we do not want to waste time doing nothing */
		}
	}
	free(vertices);
	return estimate;
}

// Assembly:
subq $0x58, %rsp
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movq %rdx, 0x38(%rsp)
movq %rcx, 0x30(%rsp)
movq $0x1, 0x20(%rsp)
movq 0x48(%rsp), %rax
movslq (%rax), %rdi
shlq $0x2, %rdi
callq 0x1170
movq %rax, 0x18(%rsp)
movq 0x40(%rsp), %rax
movq %rax, 0x28(%rsp)
cmpq $0x0, 0x28(%rsp)
je 0x32715
movq 0x28(%rsp), %rax
cmpl $0x1, 0x10(%rax)
je 0x326fe
movq 0x28(%rsp), %rdi
movq 0x48(%rsp), %rax
movl (%rax), %esi
movq 0x18(%rsp), %rdx
callq 0x324a0
movl %eax, 0x14(%rsp)
movq 0x28(%rsp), %rdi
movq 0x38(%rsp), %rsi
movq 0x30(%rsp), %rdx
callq 0x241c0
cmpb $0x0, %al
jne 0x326b8
movq 0x28(%rsp), %rax
movslq 0x10(%rax), %rdi
movslq 0x14(%rsp), %rsi
callq 0x322e0
movq %rax, 0x8(%rsp)
cmpq $-0x1, 0x8(%rsp)
jne 0x326a6
movq 0x18(%rsp), %rdi
callq 0x1030
movq $-0x1, 0x50(%rsp)
jmp 0x32729
movq 0x8(%rsp), %rax
imulq 0x20(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x326fc
movq 0x28(%rsp), %rax
movslq 0x10(%rax), %rdi
movslq 0x14(%rsp), %rsi
callq 0x32310
movq %rax, (%rsp)
cmpq $-0x1, (%rsp)
jne 0x326eb
movq 0x18(%rsp), %rdi
callq 0x1030
movq $-0x1, 0x50(%rsp)
jmp 0x32729
movq (%rsp), %rax
imulq 0x20(%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x326fc
jmp 0x32700
jmp 0x32700
jmp 0x32702
movq 0x28(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x28(%rsp)
jmp 0x32621
movq 0x18(%rsp), %rdi
callq 0x1030
movq 0x20(%rsp), %rax
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/upperBoundsForSpanningTrees.c
// Function: getEstimate
long int getEstimate(struct Graph* g, long int estimateFunction(long int, long int), char checkOuterplanarity, struct ShallowGraphPool* sgp, struct GraphPool* gp) {
	struct ShallowGraph* biconnectedComponents = listBiconnectedComponents(g, sgp);
	struct ShallowGraph* idx;
	long int estimate = 1;
	int* vertices = malloc(g->n * sizeof(int));

	for (idx=biconnectedComponents; idx!=NULL; idx=idx->next) {
		if (idx->m != 1) {
			int nInd;
			if (checkOuterplanarity) {
				if (!isOuterplanarBlockShallow(idx, sgp, gp)) {
					dumpShallowGraphCycle(sgp, biconnectedComponents);
					return -1;
				} else {
					
				}

			}
			nInd = getVertexNumberOfInducedGraph(idx, g->n, vertices);
			/* printf("(%li %i %i) ", estimateFunction(idx->m, nInd), nInd, idx->m); */
			estimate *= estimateFunction(idx->m, nInd);
		}
	}

	dumpShallowGraphCycle(sgp, biconnectedComponents);
	free(vertices);
	return estimate;
}

// Assembly:
subq $0x58, %rsp
movb %dl, %al
movq %rdi, 0x48(%rsp)
movq %rsi, 0x40(%rsp)
movb %al, 0x3f(%rsp)
movq %rcx, 0x30(%rsp)
movq %r8, 0x28(%rsp)
movq 0x48(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0x10700
movq %rax, 0x20(%rsp)
movq $0x1, 0x10(%rsp)
movq 0x48(%rsp), %rax
movslq (%rax), %rdi
shlq $0x2, %rdi
callq 0x1170
movq %rax, 0x8(%rsp)
movq 0x20(%rsp), %rax
movq %rax, 0x18(%rsp)
cmpq $0x0, 0x18(%rsp)
je 0x3283e
movq 0x18(%rsp), %rax
cmpl $0x1, 0x10(%rax)
je 0x32829
cmpb $0x0, 0x3f(%rsp)
je 0x327ef
movq 0x18(%rsp), %rdi
movq 0x30(%rsp), %rsi
movq 0x28(%rsp), %rdx
callq 0x241c0
cmpb $0x0, %al
jne 0x327eb
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x20000
movq $-0x1, 0x50(%rsp)
jmp 0x32861
jmp 0x327ed
jmp 0x327ef
movq 0x18(%rsp), %rdi
movq 0x48(%rsp), %rax
movl (%rax), %esi
movq 0x8(%rsp), %rdx
callq 0x324a0
movl %eax, 0x4(%rsp)
movq 0x40(%rsp), %rax
movq 0x18(%rsp), %rcx
movslq 0x10(%rcx), %rdi
movslq 0x4(%rsp), %rsi
callq *%rax
imulq 0x10(%rsp), %rax
movq %rax, 0x10(%rsp)
jmp 0x3282b
movq 0x18(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x18(%rsp)
jmp 0x3279b
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0x20000
movq 0x8(%rsp), %rdi
callq 0x1030
movq 0x10(%rsp), %rax
movq %rax, 0x50(%rsp)
movq 0x50(%rsp), %rax
addq $0x58, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/vertexQueue.c
// Function: popFromVertexQueue
struct Vertex* popFromVertexQueue(struct ShallowGraph* queue, struct ShallowGraphPool* sgp) {
	struct VertexList* e = popEdge(queue);
	if (e != NULL) {
		struct Vertex* v = e->endPoint;
		dumpVertexList(sgp->listPool, e);
		return v;
	} else {
		return NULL;
	}
}

// Assembly:
subq $0x28, %rsp
movq %rdi, 0x18(%rsp)
movq %rsi, 0x10(%rsp)
movq 0x18(%rsp), %rdi
callq 0xbef0
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x32910
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, (%rsp)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0x1f410
movq (%rsp), %rax
movq %rax, 0x20(%rsp)
jmp 0x32919
movq $0x0, 0x20(%rsp)
movq 0x20(%rsp), %rax
addq $0x28, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/vertexQueue.c
// Function: peekFromVertexQueue
struct Vertex* peekFromVertexQueue(struct ShallowGraph* queue) {
	struct VertexList* e = queue->edges;
	if (e != NULL) {
		return e->endPoint;
	} else {
		return NULL;
	}
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq %rax, -0x18(%rsp)
cmpq $0x0, -0x18(%rsp)
je 0x3295a
movq -0x18(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x8(%rsp)
jmp 0x32963
movq $0x0, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/weisfeilerLehman.c
// Function: weisfeilerLehmanRelabel
struct Graph* weisfeilerLehmanRelabel(struct Graph* g, struct Vertex* wlLabels, struct GraphPool* gp, struct ShallowGraphPool* sgp) {
	struct Graph* h = cloneGraph(g, gp);
	int v;

	for (v=0; v<g->n; ++v) {
		h->vertices[v]->label = getWLLabel(g->vertices[v], wlLabels, gp, sgp);
		h->vertices[v]->isStringMaster = 1;
	}
	// fprintf(stderr, "\n\n\n");
	// printStringsInSearchTree(wlLabels, stderr, sgp);
	return h;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq %rdx, 0x20(%rsp)
movq %rcx, 0x18(%rsp)
movq 0x30(%rsp), %rdi
movq 0x20(%rsp), %rsi
callq 0xacb0
movq %rax, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl 0xc(%rsp), %eax
movq 0x30(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x32c45
movq 0x30(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
movq 0x28(%rsp), %rsi
movq 0x20(%rsp), %rdx
movq 0x18(%rsp), %rcx
callq 0x32970
movq %rax, %rcx
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0xc(%rsp), %rdx
movq (%rax,%rdx,8), %rax
movq %rcx, (%rax)
movq 0x10(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movl $0x1, 0x24(%rax)
movl 0xc(%rsp), %eax
addl $0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x32bd4
movq 0x10(%rsp), %rax
addq $0x38, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/wilsonsAlgorithm.c
// Function: initIntegerArrayStack
struct IntegerArrayStack* initIntegerArrayStack(int capacity) {
	struct IntegerArrayStack* ias = malloc(sizeof(struct IntegerArrayStack));
	ias->stackData = malloc(capacity * sizeof(int));
	ias->top = -1;
	ias->capacity = capacity;
	return ias;
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movl $0x10, %edi
callq 0x1170
movq %rax, 0x8(%rsp)
movslq 0x14(%rsp), %rdi
shlq $0x2, %rdi
callq 0x1170
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
movl 0x14(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0xc(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/wilsonsAlgorithm.c
// Function: ias_pop
int ias_pop(struct IntegerArrayStack* ias) {
	if (ias->top != -1) {
		return ias->stackData[ias->top--];
	} else {
		return -1;
	}
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq -0x10(%rsp), %rax
cmpl $-0x1, 0x8(%rax)
je 0x32d14
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq -0x10(%rsp), %rdx
movl 0x8(%rdx), %ecx
movl %ecx, %esi
addl $-0x1, %esi
movl %esi, 0x8(%rdx)
movslq %ecx, %rcx
movl (%rax,%rcx,4), %eax
movl %eax, -0x4(%rsp)
jmp 0x32d1c
movl $0xffffffff, -0x4(%rsp) # imm = 0xFFFFFFFF
movl -0x4(%rsp), %eax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/wilsonsAlgorithm.c
// Function: ias_shuffleArray
void ias_shuffleArray(struct IntegerArrayStack* ias) {
	int i;
	for (i = ias->capacity - 1; i > 0; i--)
	{
		int index = rand() % (i + 1);
		// Simple swap
		int a = ias->stackData[index];
		ias->stackData[index] = ias->stackData[i];
		ias->stackData[i] = a;
	}
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq 0x10(%rsp), %rax
movl 0xc(%rax), %eax
subl $0x1, %eax
movl %eax, 0xc(%rsp)
cmpl $0x0, 0xc(%rsp)
jle 0x32de7
callq 0x1220
movl 0xc(%rsp), %ecx
addl $0x1, %ecx
cltd
idivl %ecx
movl %edx, 0x8(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movslq 0x8(%rsp), %rcx
movl (%rax,%rcx,4), %eax
movl %eax, 0x4(%rsp)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movslq 0xc(%rsp), %rcx
movl (%rax,%rcx,4), %edx
movq 0x10(%rsp), %rax
movq (%rax), %rax
movslq 0x8(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movl 0x4(%rsp), %edx
movq 0x10(%rsp), %rax
movq (%rax), %rax
movslq 0xc(%rsp), %rcx
movl %edx, (%rax,%rcx,4)
movl 0xc(%rsp), %eax
addl $-0x1, %eax
movl %eax, 0xc(%rsp)
jmp 0x32d78
addq $0x18, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/wilsonsAlgorithm.c
// Function: initArrayList
struct ArrayList* initArrayList(int capacity) {
	struct ArrayList* al = malloc(sizeof(struct ArrayList));
	al->stackData = malloc(capacity * sizeof(int*));
	al->top = -1;
	al->capacity = capacity;
	return al;
}

// Assembly:
subq $0x18, %rsp
movl %edi, 0x14(%rsp)
movl $0x10, %edi
callq 0x1170
movq %rax, 0x8(%rsp)
movslq 0x14(%rsp), %rdi
shlq $0x3, %rdi
callq 0x1170
movq %rax, %rcx
movq 0x8(%rsp), %rax
movq %rcx, (%rax)
movq 0x8(%rsp), %rax
movl $0xffffffff, 0x8(%rax)  # imm = 0xFFFFFFFF
movl 0x14(%rsp), %ecx
movq 0x8(%rsp), %rax
movl %ecx, 0xc(%rax)
movq 0x8(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/wilsonsAlgorithm.c
// Function: al_pop
int* al_pop(struct ArrayList* al) {
	if (al->top != -1) {
		return al->stackData[al->top--];
	} else {
		return NULL;
	}
}

// Assembly:
movq %rdi, -0x10(%rsp)
movq -0x10(%rsp), %rax
cmpl $-0x1, 0x8(%rax)
je 0x32eb6
movq -0x10(%rsp), %rax
movq (%rax), %rax
movq -0x10(%rsp), %rdx
movl 0x8(%rdx), %ecx
movl %ecx, %esi
addl $-0x1, %esi
movl %esi, 0x8(%rdx)
movslq %ecx, %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x8(%rsp)
jmp 0x32ebf
movq $0x0, -0x8(%rsp)
movq -0x8(%rsp), %rax
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/wilsonsAlgorithm.c
// Function: randomSpanningTreeAsShallowGraph
struct ShallowGraph* randomSpanningTreeAsShallowGraph(struct Graph* g, struct ShallowGraphPool* sgp) {
	if (g->m == 0) {
		return getShallowGraph(sgp);
	} else {
		return _randomSpanningTreeAsShallowGraph(g, sgp);
	}
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x8(%rsp)
movq %rsi, (%rsp)
movq 0x8(%rsp), %rax
cmpl $0x0, 0x4(%rax)
jne 0x32f28
movq (%rsp), %rdi
callq 0x1fe70
movq %rax, 0x10(%rsp)
jmp 0x32f3b
movq 0x8(%rsp), %rdi
movq (%rsp), %rsi
callq 0x32f50
movq %rax, 0x10(%rsp)
movq 0x10(%rsp), %rax
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/wilsonsAlgorithm.c
// Function: randomSpanningTreeAsShallowGraph
static struct ShallowGraph* _randomSpanningTreeAsShallowGraph(struct Graph* g, struct ShallowGraphPool* sgp) {
	int i, start;
	struct VertexList** previous = malloc(g->n * sizeof(struct VertexList*)); // current random walk
	char* used = malloc(g->n * sizeof(char));
	struct ShallowGraph* tree = getShallowGraph(sgp);
	struct IntegerArrayStack* remaining = initIntegerArrayStack(g->n); // cell indexes to visit
	for (i=0; i<g->n; ++i) {
		ias_push(i, remaining);
		previous[i] = NULL;
		used[i] = 0;
	}
	ias_shuffleArray(remaining);

	// Add a random cell.
	start = ias_pop(remaining);
	used[start] = 1;

	// While there are remaining cells,
	// add a loop-erased random walk to the maze.
	while (!loopErasedRandomWalk(g, remaining, previous, used, tree, sgp->listPool));

	ias_free(remaining);
	free(previous);
	free(used);

	return tree;
}

// Assembly:
subq $0x38, %rsp
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movq 0x30(%rsp), %rax
movslq (%rax), %rdi
shlq $0x3, %rdi
callq 0x1170
movq %rax, 0x18(%rsp)
movq 0x30(%rsp), %rax
movslq (%rax), %rdi
shlq $0x0, %rdi
callq 0x1170
movq %rax, 0x10(%rsp)
movq 0x28(%rsp), %rdi
callq 0x1fe70
movq %rax, 0x8(%rsp)
movq 0x30(%rsp), %rax
movl (%rax), %edi
callq 0x32c50
movq %rax, (%rsp)
movl $0x0, 0x24(%rsp)
movl 0x24(%rsp), %eax
movq 0x30(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x32ff8
movl 0x24(%rsp), %edi
movq (%rsp), %rsi
callq 0x32cb0
movq 0x18(%rsp), %rax
movslq 0x24(%rsp), %rcx
movq $0x0, (%rax,%rcx,8)
movq 0x10(%rsp), %rax
movslq 0x24(%rsp), %rcx
movb $0x0, (%rax,%rcx)
movl 0x24(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x24(%rsp)
jmp 0x32fb1
movq (%rsp), %rdi
callq 0x32d60
movq (%rsp), %rdi
callq 0x32ce0
movl %eax, 0x20(%rsp)
movq 0x10(%rsp), %rax
movslq 0x20(%rsp), %rcx
movb $0x1, (%rax,%rcx)
movq 0x30(%rsp), %rdi
movq (%rsp), %rsi
movq 0x18(%rsp), %rdx
movq 0x10(%rsp), %rcx
movq 0x8(%rsp), %r8
movq 0x28(%rsp), %rax
movq 0x10(%rax), %r9
callq 0x33100
cmpb $0x0, %al
setne %al
xorb $-0x1, %al
testb $0x1, %al
jne 0x3304f
jmp 0x33051
jmp 0x3301c
movq (%rsp), %rdi
callq 0x32d30
movq 0x18(%rsp), %rdi
callq 0x1030
movq 0x10(%rsp), %rdi
callq 0x1030
movq 0x8(%rsp), %rax
addq $0x38, %rsp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/wilsonsAlgorithm.c
// Function: eraseWalk
void eraseWalk(int index0, int index1, struct VertexList** previous) {
	int index;
	for (index=previous[index0]->startPoint->number; 
		index!=index1; 
		index=previous[index0]->startPoint->number) {
		//debug
		// printf("erase ");
		// printEdge(previous[index0]);

		previous[index0] = NULL;
		index0 = index;
	}
	previous[index0] = NULL;
}

// Assembly:
movl %edi, -0x4(%rsp)
movl %esi, -0x8(%rsp)
movq %rdx, -0x10(%rsp)
movq -0x10(%rsp), %rax
movslq -0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rax
movl 0x18(%rax), %eax
movl %eax, -0x14(%rsp)
movl -0x14(%rsp), %eax
cmpl -0x8(%rsp), %eax
je 0x330e5
movq -0x10(%rsp), %rax
movslq -0x4(%rsp), %rcx
movq $0x0, (%rax,%rcx,8)
movl -0x14(%rsp), %eax
movl %eax, -0x4(%rsp)
movq -0x10(%rsp), %rax
movslq -0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movq 0x10(%rax), %rax
movl 0x18(%rax), %eax
movl %eax, -0x14(%rsp)
jmp 0x330a6
movq -0x10(%rsp), %rax
movslq -0x4(%rsp), %rcx
movq $0x0, (%rax,%rcx,8)
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/executables/outerplanaritytest.c
// Function: printHelp
int printHelp() {
#include "../o/help/outerplanaritytestHelp.help"
	unsigned char* help = executables_outerplanaritytestHelp_txt;
	int len = executables_outerplanaritytestHelp_txt_len;
	if (help != NULL) {
		int i=0;
		for (i=0; i<len; ++i) {
			fputc(help[i], stdout);
		}
		return EXIT_SUCCESS;
	} else {
		fprintf(stderr, "Could not read help file\n");
		return EXIT_FAILURE;
	}
}

// Assembly:
subq $0x4d8, %rsp            # imm = 0x4D8
leaq 0x20(%rsp), %rdi
leaq 0x2d8d(%rip), %rsi      # 0x36110
movl $0x4a7, %edx            # imm = 0x4A7
callq 0x1150
movl $0x4a7, 0x1c(%rsp)      # imm = 0x4A7
leaq 0x20(%rsp), %rax
movq %rax, 0x10(%rsp)
movl 0x1c(%rsp), %eax
movl %eax, 0xc(%rsp)
cmpq $0x0, 0x10(%rsp)
je 0x33400
movl $0x0, 0x8(%rsp)
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
cmpl 0xc(%rsp), %eax
jge 0x333f3
movq 0x10(%rsp), %rax
movslq 0x8(%rsp), %rcx
movzbl (%rax,%rcx), %edi
movq 0xabea(%rip), %rax      # 0x3dfc8
movq (%rax), %rsi
callq 0x10f0
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x333bf
movl $0x0, 0x4d4(%rsp)
jmp 0x33423
movq 0xabf1(%rip), %rax      # 0x3dff8
movq (%rax), %rdi
leaq 0x31a6(%rip), %rsi      # 0x365b7
movb $0x0, %al
callq 0x1140
movl $0x1, 0x4d4(%rsp)
movl 0x4d4(%rsp), %eax
addq $0x4d8, %rsp            # imm = 0x4D8
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/executables/outerplanaritytest.c
// Function: addSpiderWebEdges
void addSpiderWebEdges(struct BBTree* bbTree, struct ShallowGraphPool* sgp) {
    printf(", \"spiderweb\": {");
    if (bbTree->tree->n > 0) {
        computeDistanceToCenter(bbTree->tree, sgp);
        char first = 1;
        for (int v=0; v<bbTree->tree->n; ++v) {
            if (first) {
                first = 0;
            } else {
                printf(", ");
            }
            printf("\"%d\": %d", bbTree->originalIDs[v], bbTree->tree->vertices[v]->lowPoint);
        }
    }
    putc('}', stdout);
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movq %rsi, 0x8(%rsp)
leaq 0x2c29(%rip), %rdi      # 0x366be
movb $0x0, %al
callq 0x1090
movq 0x10(%rsp), %rax
movq (%rax), %rax
cmpl $0x0, (%rax)
jle 0x33b38
movq 0x10(%rsp), %rax
movq (%rax), %rdi
movq 0x8(%rsp), %rsi
callq 0x30840
movb $0x1, 0x7(%rsp)
movl $0x0, (%rsp)
movl (%rsp), %eax
movq 0x10(%rsp), %rcx
movq (%rcx), %rcx
cmpl (%rcx), %eax
jge 0x33b36
cmpb $0x0, 0x7(%rsp)
je 0x33ae8
movb $0x0, 0x7(%rsp)
jmp 0x33af6
leaq 0x1956(%rip), %rdi      # 0x35445
movb $0x0, %al
callq 0x1090
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rax
movslq (%rsp), %rcx
movl (%rax,%rcx,4), %esi
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movslq (%rsp), %rcx
movq (%rax,%rcx,8), %rax
movl 0x20(%rax), %edx
leaq 0x2bab(%rip), %rdi      # 0x366cf
movb $0x0, %al
callq 0x1090
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0x33acb
jmp 0x33b38
movq 0xa489(%rip), %rax      # 0x3dfc8
movq (%rax), %rsi
movl $0x7d, %edi
callq 0x1110
addq $0x18, %rsp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/executables/outerplanaritytest.c
// Function: printInterestingEdges
char printInterestingEdges(struct Vertex* lastInteresting, struct Vertex* v, char notFirst, int* originalIDs, char printAll) {
    v->visited = 1;
    if (v->lowPoint) {
        if (lastInteresting) {
            char isNeighbor = 0;
            for (struct VertexList* e=v->neighborhood; e!=NULL; e=e->next) {
                if (e->endPoint == lastInteresting) {
                    isNeighbor = 1;
                    break;
                }
            }
            if (printAll || !isNeighbor) {
                if (notFirst) {
                    printf(", ");
                }
                printf("[%d, %d]", originalIDs[lastInteresting->number], originalIDs[v->number]);
                notFirst = 1;
            }
        }
    }
    for (struct VertexList* e=v->neighborhood; e!=NULL; e=e->next) {
        if (e->endPoint->visited == 0) {
            if (v->lowPoint) {
                notFirst = printInterestingEdges(v, e->endPoint, notFirst, originalIDs, printAll);
            } else {
                notFirst = printInterestingEdges(lastInteresting, e->endPoint, notFirst, originalIDs, printAll);
            }
        }
    }
    return notFirst;
}

// Assembly:
subq $0x38, %rsp
movb %r8b, %al
movq %rdi, 0x30(%rsp)
movq %rsi, 0x28(%rsp)
movb %dl, 0x27(%rsp)
movq %rcx, 0x18(%rsp)
movb %al, 0x17(%rsp)
movq 0x28(%rsp), %rax
movl $0x1, 0x1c(%rax)
movq 0x28(%rsp), %rax
cmpl $0x0, 0x20(%rax)
je 0x33c48
cmpq $0x0, 0x30(%rsp)
je 0x33c46
movb $0x0, 0x16(%rsp)
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
cmpq $0x0, 0x8(%rsp)
je 0x33be9
movq 0x8(%rsp), %rax
movq 0x18(%rax), %rax
cmpq 0x30(%rsp), %rax
jne 0x33bd7
movb $0x1, 0x16(%rsp)
jmp 0x33be9
jmp 0x33bd9
movq 0x8(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x8(%rsp)
jmp 0x33bb8
movsbl 0x17(%rsp), %eax
cmpl $0x0, %eax
jne 0x33bfa
cmpb $0x0, 0x16(%rsp)
jne 0x33c44
cmpb $0x0, 0x27(%rsp)
je 0x33c0f
leaq 0x183d(%rip), %rdi      # 0x35445
movb $0x0, %al
callq 0x1090
movq 0x18(%rsp), %rax
movq 0x30(%rsp), %rcx
movslq 0x18(%rcx), %rcx
movl (%rax,%rcx,4), %esi
movq 0x18(%rsp), %rax
movq 0x28(%rsp), %rcx
movslq 0x18(%rcx), %rcx
movl (%rax,%rcx,4), %edx
leaq 0x2aa0(%rip), %rdi      # 0x366d8
movb $0x0, %al
callq 0x1090
movb $0x1, 0x27(%rsp)
jmp 0x33c46
jmp 0x33c48
movq 0x28(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
cmpq $0x0, (%rsp)
je 0x33ce0
movq (%rsp), %rax
movq 0x18(%rax), %rax
cmpl $0x0, 0x1c(%rax)
jne 0x33ccd
movq 0x28(%rsp), %rax
cmpl $0x0, 0x20(%rax)
je 0x33ca3
movq 0x28(%rsp), %rdi
movq (%rsp), %rax
movq 0x18(%rax), %rsi
movb 0x27(%rsp), %al
movq 0x18(%rsp), %rcx
movsbl %al, %edx
movsbl 0x17(%rsp), %r8d
callq 0x33b60
movb %al, 0x27(%rsp)
jmp 0x33ccb
movq 0x30(%rsp), %rdi
movq (%rsp), %rax
movq 0x18(%rax), %rsi
movb 0x27(%rsp), %al
movq 0x18(%rsp), %rcx
movsbl %al, %edx
movsbl 0x17(%rsp), %r8d
callq 0x33b60
movb %al, 0x27(%rsp)
jmp 0x33ccd
jmp 0x33ccf
movq (%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, (%rsp)
jmp 0x33c55
movb 0x27(%rsp), %al
addq $0x38, %rsp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/executables/outerplanaritytest.c
// Function: addShortcutEdges
void addShortcutEdges(struct BBTree* bbTree, char printAll) {
    int root = 0;
    /* mark interesting vertices, keep the last leaf or join as root */
    for (int v=0; v<bbTree->tree->n; ++v) {
        bbTree->tree->vertices[v]->visited = 0;
        if (degree(bbTree->tree->vertices[v]) != 2) {
            bbTree->tree->vertices[v]->lowPoint = 1;
            root = v;
        } else {
            bbTree->tree->vertices[v]->lowPoint = 0;
        } 
    }
    if (bbTree->blocks) {
        for (int v=0; v<bbTree->blocks->n; ++v) {
            bbTree->blocks->vertices[v]->lowPoint = 2;
        }
    }

    printf(", \"shortcutEdges\": [");
    printInterestingEdges(NULL, bbTree->tree->vertices[root], 0, bbTree->originalIDs, printAll);
    printf("]");
}

// Assembly:
subq $0x18, %rsp
movb %sil, %al
movq %rdi, 0x10(%rsp)
movb %al, 0xf(%rsp)
movl $0x0, 0x8(%rsp)
movl $0x0, 0x4(%rsp)
movl 0x4(%rsp), %eax
movq 0x10(%rsp), %rcx
movq (%rcx), %rcx
cmpl (%rcx), %eax
jge 0x33db3
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movl $0x0, 0x1c(%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0xa440
cmpl $0x2, %eax
je 0x33d85
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movl $0x1, 0x20(%rax)
movl 0x4(%rsp), %eax
movl %eax, 0x8(%rsp)
jmp 0x33da1
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movslq 0x4(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movl $0x0, 0x20(%rax)
jmp 0x33da3
movl 0x4(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x4(%rsp)
jmp 0x33d10
movq 0x10(%rsp), %rax
cmpq $0x0, 0x8(%rax)
je 0x33dff
movl $0x0, (%rsp)
movl (%rsp), %eax
movq 0x10(%rsp), %rcx
movq 0x8(%rcx), %rcx
cmpl (%rcx), %eax
jge 0x33dfd
movq 0x10(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x10(%rax), %rax
movslq (%rsp), %rcx
movq (%rax,%rcx,8), %rax
movl $0x2, 0x20(%rax)
movl (%rsp), %eax
addl $0x1, %eax
movl %eax, (%rsp)
jmp 0x33dc6
jmp 0x33dff
leaq 0x28db(%rip), %rdi      # 0x366e1
movb $0x0, %al
callq 0x1090
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movslq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rcx
xorl %eax, %eax
movl %eax, %edi
xorl %edx, %edx
movsbl 0xf(%rsp), %r8d
callq 0x33b60
leaq 0x1282(%rip), %rdi      # 0x350c5
movb $0x0, %al
callq 0x1090
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/executables/outerplanaritytest.c
// Function: printBBTreeEdges
void printBBTreeEdges(struct BBTree* bbTree) {
    int root = 0;
    /* mark all vertices as interesting */
    for (int v=0; v<bbTree->tree->n; ++v) {
        bbTree->tree->vertices[v]->visited = 0;
        bbTree->tree->vertices[v]->lowPoint = 1;
    }

    printf(", \"CATree\": [");
    printInterestingEdges(NULL, bbTree->tree->vertices[root], 0, bbTree->originalIDs, 1);
    printf("]");
}

// Assembly:
subq $0x18, %rsp
movq %rdi, 0x10(%rsp)
movl $0x0, 0xc(%rsp)
movl $0x0, 0x8(%rsp)
movl 0x8(%rsp), %eax
movq 0x10(%rsp), %rcx
movq (%rcx), %rcx
cmpl (%rcx), %eax
jge 0x33ebe
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movslq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movl $0x0, 0x1c(%rax)
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movslq 0x8(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movl $0x1, 0x20(%rax)
movl 0x8(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x8(%rsp)
jmp 0x33e69
leaq 0x2831(%rip), %rdi      # 0x366f6
movb $0x0, %al
callq 0x1090
movq 0x10(%rsp), %rax
movq (%rax), %rax
movq 0x10(%rax), %rax
movslq 0xc(%rsp), %rcx
movq (%rax,%rcx,8), %rsi
movq 0x10(%rsp), %rax
movq 0x18(%rax), %rcx
xorl %eax, %eax
movl %eax, %edi
xorl %edx, %edx
movl $0x1, %r8d
callq 0x33b60
leaq 0x11c3(%rip), %rdi      # 0x350c5
movb $0x0, %al
callq 0x1090
addq $0x18, %rsp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/ataradov[P]edbg/dap.c
// Function: dap_led
void dap_led(int index, int state)
{
  uint8_t buf[3];

  buf[0] = ID_DAP_LED;
  buf[1] = index;
  buf[2] = state;
  dbg_dap_cmd(buf, sizeof(buf), 3);

  check(DAP_OK == buf[0], "DAP_LED failed");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movb $0x1, -0xb(%rbp)
movl -0x4(%rbp), %eax
movb %al, -0xa(%rbp)
movl -0x8(%rbp), %eax
movb %al, -0x9(%rbp)
leaq -0xb(%rbp), %rdi
movl $0x3, %edx
movl %edx, %esi
callq 0x130d0
movzbl -0xb(%rbp), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
sete %al
movzbl %al, %edi
andl $0x1, %edi
leaq 0xdb9e(%rip), %rsi      # 0x14004
xorl %eax, %eax
callq 0x8880
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ataradov[P]edbg/dap.c
// Function: dap_connect
void dap_connect(int interf)
{
  uint8_t buf[2];
  int cap = (DAP_INTERFACE_SWD == interf) ? DAP_CAP_SWD : DAP_CAP_JTAG;

  buf[0] = ID_DAP_CONNECT;
  buf[1] = cap;
  dbg_dap_cmd(buf, sizeof(buf), 2);

  check(buf[0] == cap, "DAP_CONNECT failed");

  dap_interface = interf;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movl -0x4(%rbp), %edx
movl $0x1, %ecx
movl $0x2, %eax
cmpl %edx, %ecx
cmovel %ecx, %eax
movl %eax, -0xc(%rbp)
movb $0x2, -0x6(%rbp)
movl -0xc(%rbp), %eax
movb %al, -0x5(%rbp)
leaq -0x6(%rbp), %rdi
movl $0x2, %edx
movl %edx, %esi
callq 0x130d0
movzbl -0x6(%rbp), %eax
cmpl -0xc(%rbp), %eax
sete %al
movzbl %al, %edi
andl $0x1, %edi
leaq 0xdb42(%rip), %rsi      # 0x14013
xorl %eax, %eax
callq 0x8880
movl -0x4(%rbp), %eax
movl %eax, 0x193cf(%rip)     # 0x1f8b0
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ataradov[P]edbg/dap.c
// Function: dap_swj_clock
void dap_swj_clock(uint32_t clock)
{
  uint8_t buf[5];

  buf[0] = ID_DAP_SWJ_CLOCK;
  buf[1] = clock & 0xff;
  buf[2] = (clock >> 8) & 0xff;
  buf[3] = (clock >> 16) & 0xff;
  buf[4] = (clock >> 24) & 0xff;
  dbg_dap_cmd(buf, sizeof(buf), 5);

  check(DAP_OK == buf[0], "SWJ_CLOCK failed");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movb $0x11, -0x9(%rbp)
movl -0x4(%rbp), %eax
andl $0xff, %eax
movb %al, -0x8(%rbp)
movl -0x4(%rbp), %eax
shrl $0x8, %eax
andl $0xff, %eax
movb %al, -0x7(%rbp)
movl -0x4(%rbp), %eax
shrl $0x10, %eax
andl $0xff, %eax
movb %al, -0x6(%rbp)
movl -0x4(%rbp), %eax
shrl $0x18, %eax
andl $0xff, %eax
movb %al, -0x5(%rbp)
leaq -0x9(%rbp), %rdi
movl $0x5, %edx
movl %edx, %esi
callq 0x130d0
movzbl -0x9(%rbp), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
sete %al
movzbl %al, %edi
andl $0x1, %edi
leaq 0xda9a(%rip), %rsi      # 0x14026
xorl %eax, %eax
callq 0x8880
addq $0x10, %rsp
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/ataradov[P]edbg/dap.c
// Function: dap_transfer_configure
void dap_transfer_configure(uint8_t idle, uint16_t retry, uint16_t match_retry)
{
  uint8_t buf[6];

  buf[0] = ID_DAP_TRANSFER_CONFIGURE;
  buf[1] = idle;
  buf[2] = retry & 0xff;
  buf[3] = (retry >> 8) & 0xff;
  buf[4] = match_retry & 0xff;
  buf[5] = (match_retry >> 8) & 0xff;
  dbg_dap_cmd(buf, sizeof(buf), 6);

  check(DAP_OK == buf[0], "TRANSFER_CONFIGURE failed");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movw %dx, %ax
movw %si, %cx
movb %dil, %dl
movb %dl, -0x1(%rbp)
movw %cx, -0x4(%rbp)
movw %ax, -0x6(%rbp)
movb $0x4, -0xc(%rbp)
movb -0x1(%rbp), %al
movb %al, -0xb(%rbp)
movzwl -0x4(%rbp), %eax
andl $0xff, %eax
movb %al, -0xa(%rbp)
movzwl -0x4(%rbp), %eax
sarl $0x8, %eax
andl $0xff, %eax
movb %al, -0x9(%rbp)
movzwl -0x6(%rbp), %eax
andl $0xff, %eax
movb %al, -0x8(%rbp)
movzwl -0x6(%rbp), %eax
sarl $0x8, %eax
andl $0xff, %eax
movb %al, -0x7(%rbp)
leaq -0xc(%rbp), %rdi
movl $0x6, %edx
movl %edx, %esi
callq 0x130d0
movzbl -0xc(%rbp), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
sete %al
movzbl %al, %edi
andl $0x1, %edi
leaq 0xda13(%rip), %rsi      # 0x14037
xorl %eax, %eax
callq 0x8880
addq $0x10, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ataradov[P]edbg/dap.c
// Function: dap_swd_configure
void dap_swd_configure(int cfg)
{
  uint8_t buf[2];

  buf[0] = ID_DAP_SWD_CONFIGURE;
  buf[1] = cfg;
  dbg_dap_cmd(buf, sizeof(buf), 2);

  check(DAP_OK == buf[0], "SWD_CONFIGURE failed");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x10, %rsp
movl %edi, -0x4(%rbp)
movb $0x13, -0x6(%rbp)
movl -0x4(%rbp), %eax
movb %al, -0x5(%rbp)
leaq -0x6(%rbp), %rdi
movl $0x2, %edx
movl %edx, %esi
callq 0x130d0
movzbl -0x6(%rbp), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
sete %al
movzbl %al, %edi
andl $0x1, %edi
leaq 0xd9d4(%rip), %rsi      # 0x14051
xorl %eax, %eax
callq 0x8880
addq $0x10, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ataradov[P]edbg/dap.c
// Function: dap_jtag_configure
void dap_jtag_configure(int count, int *ir_len)
{
  uint8_t buf[32];

  buf[0] = ID_DAP_JTAG_CONFIGURE;
  buf[1] = count;
  for (int i = 0; i < count; i++)
    buf[2+i] = ir_len[i];
  dbg_dap_cmd(buf, sizeof(buf), 2 + count);

  check(DAP_OK == buf[0], "JTAG_CONFIGURE failed");
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x40, %rsp
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movb $0x15, -0x30(%rbp)
movl -0x4(%rbp), %eax
movb %al, -0x2f(%rbp)
movl $0x0, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x4(%rbp), %eax
jge 0x66dc
movq -0x10(%rbp), %rax
movslq -0x34(%rbp), %rcx
movl (%rax,%rcx,4), %eax
movb %al, %cl
movl -0x34(%rbp), %eax
addl $0x2, %eax
cltq
movb %cl, -0x30(%rbp,%rax)
movl -0x34(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x34(%rbp)
jmp 0x66b0
leaq -0x30(%rbp), %rdi
movl -0x4(%rbp), %edx
addl $0x2, %edx
movl $0x20, %esi
callq 0x130d0
movzbl -0x30(%rbp), %ecx
xorl %eax, %eax
cmpl %ecx, %eax
sete %al
movzbl %al, %edi
andl $0x1, %edi
leaq 0xd95e(%rip), %rsi      # 0x14066
xorl %eax, %eax
callq 0x8880
addq $0x40, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/ataradov[P]edbg/dap.c
// Function: dap_info
int dap_info(int info, uint8_t *data, int size)
{
  uint8_t buf[256];
  int rsize;

  buf[0] = ID_DAP_INFO;
  buf[1] = info;
  dbg_dap_cmd(buf, sizeof(buf), 2);

  rsize = (size < buf[0]) ? size : buf[0];
  memcpy(data, &buf[1], rsize);

  if (rsize < size)
    data[rsize] = 0;

  return rsize;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x130, %rsp            # imm = 0x130
movl %edi, -0x4(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
movb $0x0, -0x120(%rbp)
movl -0x4(%rbp), %eax
movb %al, -0x11f(%rbp)
leaq -0x120(%rbp), %rdi
movl $0x100, %esi            # imm = 0x100
movl $0x2, %edx
callq 0x130d0
movl -0x14(%rbp), %eax
movzbl -0x120(%rbp), %ecx
cmpl %ecx, %eax
jge 0x6794
movl -0x14(%rbp), %eax
movl %eax, -0x128(%rbp)
jmp 0x67a1
movzbl -0x120(%rbp), %eax
movl %eax, -0x128(%rbp)
movl -0x128(%rbp), %eax
movl %eax, -0x124(%rbp)
movq -0x10(%rbp), %rdi
leaq -0x120(%rbp), %rsi
addq $0x1, %rsi
movslq -0x124(%rbp), %rdx
callq 0x61a0
movl -0x124(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x67e2
movq -0x10(%rbp), %rax
movslq -0x124(%rbp), %rcx
movb $0x0, (%rax,%rcx)
movl -0x124(%rbp), %eax
addq $0x130, %rsp            # imm = 0x130
popq %rbp
retq
nopw %cs:(%rax,%rax)