// File: /workspace/github_c_makefile_star2_O0/pwelke[P]GraphMiningTools/outerplanar.c
// Function: isOuterplanarBlock
char isOuterplanarBlock(struct Graph* g, struct ShallowGraphPool* sgp) {
	struct ShallowGraph* list = getShallowGraph(sgp);
	struct ShallowGraph* pairs = getShallowGraph(sgp);
	struct ShallowGraph* edges = getGraphEdges(g, sgp);
	struct VertexList* node = NULL;
	struct VertexList* pair = NULL;
	struct VertexList** edgeArray;
	struct VertexList** pairArray;
	struct VertexList* idx;
	int i, j, k;
	int n = 0;
	char found;


	/*
	 * Get a list "list" of vertices of degree 2 and mark them as such in the graph
	 * by setting ->d = 1. Also, count the number of not-NULL vertices.
	 * This is useful if the algorithm gets some "induced subgraph" where some
	 * vertices are not used.
	 */
	for (i=0; i<g->n; ++i) {
		if (g->vertices[i]) {

			++n;

			/* if vertex has degree 2, add it to list and mark it as such */
			if (isDegreeTwoVertex(g->vertices[i])) {
				struct VertexList* e = getVertexList(sgp->listPool);
				e->endPoint = g->vertices[i];
				pushEdge(list, e);

				g->vertices[i]->d = 1;
			}
		}
	}

	/* first check. number of edges ok ? */
	if (g->m > 2 * n - 3) {
		/* printf("incorrect edge count\n"); */
		dumpShallowGraph(sgp, list);
		dumpShallowGraph(sgp, pairs);
		dumpShallowGraph(sgp, edges);
		return 0;
	}

	/* second check: enough vertices of degree 2? */
	if (list->m < 2) {
		/* printf("not enough vertices of degree 2\n"); */
		dumpShallowGraph(sgp, list);
		dumpShallowGraph(sgp, pairs);
		dumpShallowGraph(sgp, edges);
		return 0;
	}

	/*
	 * Successively remove vertices of degree 2
	 */
	for (i=1, node=list->edges; /*node && */  (i<=n-2);  ++i, node=node->next) {

		struct Vertex* v = node->endPoint;

		/* near and next are the two vertices adjacent to node */
		struct Vertex* near = v->neighborhood->endPoint;
		struct Vertex* next = v->neighborhood->next->endPoint;

		/* if the edges leading to near and next are artificial triangulation
		 * edges that were added below in a previous step, add them to the
		 * edges list. Do it s.t. startPoint->number <= endPoint->number, as
		 * there will be lexicographic sorting */
		if (v->neighborhood->flag) {
			if (v->number < near->number) {
				appendEdge(edges, shallowCopyEdge(v->neighborhood, sgp->listPool));
			} else {
				appendEdge(edges, inverseEdge(v->neighborhood, sgp->listPool));
			}
		}
		if (v->neighborhood->next->flag) {
			if (v->number < next->number) {
				appendEdge(edges, shallowCopyEdge(v->neighborhood->next, sgp->listPool));
			} else {
				appendEdge(edges, inverseEdge(v->neighborhood->next, sgp->listPool));
			}
		}


		/* add the pair (near, next) to pairs list, sort lexicographically
		 we have to add pair to the adjacency list of the graph, if this edge
		 does not already exist. Mark newly added edges in the flag tag. */
		pair = getVertexList(sgp->listPool);

		if (near->number < next->number) {

			pair->startPoint = near;
			pair->endPoint = next;

			/* this is for the case where g is not maximal outerplanar and
			 * a "triangulation edge" is added */
			if (!isIncident(near, next)) {
				struct VertexList* tmp = shallowCopyEdge(pair, sgp->listPool);
				tmp->flag = 1;
				addEdge(near, tmp);

				tmp = inverseEdge(pair, sgp->listPool);
				tmp->flag = 1;
				addEdge(next, tmp);
			}
		} else {

			pair->startPoint = next;
			pair->endPoint = near;

			/* this is for the case where g is not maximal outerplanar and
			 * a "triangulation edge" is added */
			if (!isIncident(near, next)) {
				struct VertexList* tmp = shallowCopyEdge(pair, sgp->listPool);
				tmp->flag = 1;
				addEdge(next, tmp);

				tmp =  inverseEdge(pair, sgp->listPool);
				tmp->flag = 1;
				addEdge(near, tmp);
			}
		}

		pushEdge(pairs, pair);

		/* remove node from Graph, check if one of the neighbors
		 * becomes degree two vertex. If it is not already in list
		 * (which is encoded in ->d), add it to list.
		 *
		 * TODO ?
		 * BUG: not degree two vertex, but 2-vertex. this is a difference
		 * But 2-vertices make no sense in the context of ops */
		removeEdge(near, v, sgp->listPool);
		if (isDegreeTwoVertex(near)) {
			if (!near->d) {
				struct VertexList* e = getVertexList(sgp->listPool);
				e->endPoint = near;
				/* printf("add %i to list of deg 2 vertices\n", near->number); */
				appendEdge(list, e);
				near->d = 1;
			}
		}

		removeEdge(next, v, sgp->listPool);
		if (isDegreeTwoVertex(next)) {
			if (!next->d) {
				struct VertexList* e = getVertexList(sgp->listPool);
				/* printf("add %i to list of deg 2 vertices\n", next->number); */
				e->endPoint = next;
				appendEdge(list, e);
				next->d = 1;
			}
		}


		/* Here, the vertex should be removed from the graph,
		 * but isMaximalOuterplanar has no pointer to a VertexPool. Thus we
		 * only dump the neighborhood of v. */
		dumpVertexListRecursively(sgp->listPool, v->neighborhood);
		v->neighborhood = NULL;


		/* this part may be omitted as it seems to be the case that
		 * "searching the list of pairs for an occurrence of something that
		 * is not in the list of edges includes an abort if there are e.g.
		 * two copies of an edge in pairs, but only one copy f that edge in
		 * edges.
		 *
		 * mistake in the paper. one has to check, if the new edge
		 * is not contained in more than two triangles. As one triangle
		 * is already deleted by removing v there can be only one other
		 * triangle left without violation of this condition in the former
		 * graph */
		if (commonNeighborCount(near, next) > 1) {
			/* printf("removing node %i creates an edge that lies on more than two triangles\n", node->endPoint->number); */
			dumpShallowGraph(sgp, list);
			dumpShallowGraph(sgp, pairs);
			dumpShallowGraph(sgp, edges);
			return 0;
		}



		/* at this point, node->endPoint should be dumped, but this is not necessary
		 * as it is not considered any more and can be handled when dumping the whole
		 * graph
		dumpVertexList(sgp->listPool, popEdge(list)); */

		if (list->m - i < 2) {
			/* printf("removing node %i leaves not enough degree 2 vertices\n", node->endPoint->number); */
			dumpShallowGraph(sgp, list);
			dumpShallowGraph(sgp, pairs);
			dumpShallowGraph(sgp, edges);
			return 0;
		}
	}

	/* add the last edge (near, next) to edges */
	appendEdge(edges, shallowCopyEdge(pair, sgp->listPool));

	/* check for occurrence of something in pairs, that is not in edges
	 * for this, sort the two lists in lexicographic order and sweep through
	 * the two arrays afterwards */
	edgeArray = malloc(edges->m * sizeof(struct VertexList*));
	for (i=0, idx=edges->edges; i<edges->m; ++i, idx=idx->next) {
		edgeArray[i] = idx;
	}

	pairArray = malloc(pairs->m * sizeof(struct VertexList*));
	for (i=0, idx=pairs->edges; i<pairs->m; ++i, idx=idx->next) {
		pairArray[i] = idx;
	}

	qsort(pairArray, pairs->m, sizeof(struct VertexList*), &compareDirectedEdges);
	qsort(edgeArray, edges->m, sizeof(struct VertexList*), &compareDirectedEdges);


	/* sweep */
	for (j=0, k=0, found=1; j<pairs->m; ++j) {

		/* increment currentEdge as long as it is lex. smaller than sweeper. */
		for (; compareDirectedEdges(&(pairArray[j]), &(edgeArray[k])) > 0; ++k);

		/* check if the two are equal */
		if (compareDirectedEdges(&(pairArray[j]), &(edgeArray[k])) == 0) {
			++k;
			continue;

		} else {
			/* this is bad, g is no mop */
			found = 0;
			break;
		}
	}

	/* garbage collection */
	dumpShallowGraph(sgp, list);
	dumpShallowGraph(sgp, pairs);
	dumpShallowGraph(sgp, edges);
	free(edgeArray);
	free(pairArray);

	return found;
}

// Assembly:
subq $0xd8, %rsp
movq %rdi, 0xc8(%rsp)
movq %rsi, 0xc0(%rsp)
movq 0xc0(%rsp), %rdi
callq 0x1fe70
movq %rax, 0xb8(%rsp)
movq 0xc0(%rsp), %rdi
callq 0x1fe70
movq %rax, 0xb0(%rsp)
movq 0xc8(%rsp), %rdi
movq 0xc0(%rsp), %rsi
callq 0xb530
movq %rax, 0xa8(%rsp)
movq $0x0, 0xa0(%rsp)
movq $0x0, 0x98(%rsp)
movl $0x0, 0x70(%rsp)
movl $0x0, 0x7c(%rsp)
movl 0x7c(%rsp), %eax
movq 0xc8(%rsp), %rcx
cmpl (%rcx), %eax
jge 0x24375
movq 0xc8(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x7c(%rsp), %rcx
cmpq $0x0, (%rax,%rcx,8)
je 0x24363
movl 0x70(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x70(%rsp)
movq 0xc8(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x7c(%rsp), %rcx
movq (%rax,%rcx,8), %rdi
callq 0xa600
cmpb $0x0, %al
je 0x24361
movq 0xc0(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x1f310
movq %rax, 0x60(%rsp)
movq 0xc8(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x7c(%rsp), %rcx
movq (%rax,%rcx,8), %rcx
movq 0x60(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0xb8(%rsp), %rdi
movq 0x60(%rsp), %rsi
callq 0xb610
movq 0xc8(%rsp), %rax
movq 0x10(%rax), %rax
movslq 0x7c(%rsp), %rcx
movq (%rax,%rcx,8), %rax
movl $0x1, 0x28(%rax)
jmp 0x24363
jmp 0x24365
movl 0x7c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x7c(%rsp)
jmp 0x242a6
movq 0xc8(%rsp), %rax
movl 0x4(%rax), %eax
movl 0x70(%rsp), %ecx
shll %ecx
subl $0x3, %ecx
cmpl %ecx, %eax
jle 0x243d9
movq 0xc0(%rsp), %rdi
movq 0xb8(%rsp), %rsi
callq 0x1ff70
movq 0xc0(%rsp), %rdi
movq 0xb0(%rsp), %rsi
callq 0x1ff70
movq 0xc0(%rsp), %rdi
movq 0xa8(%rsp), %rsi
callq 0x1ff70
movb $0x0, 0xd7(%rsp)
jmp 0x24c02
movq 0xb8(%rsp), %rax
cmpl $0x2, 0x10(%rax)
jge 0x24433
movq 0xc0(%rsp), %rdi
movq 0xb8(%rsp), %rsi
callq 0x1ff70
movq 0xc0(%rsp), %rdi
movq 0xb0(%rsp), %rsi
callq 0x1ff70
movq 0xc0(%rsp), %rdi
movq 0xa8(%rsp), %rsi
callq 0x1ff70
movb $0x0, 0xd7(%rsp)
jmp 0x24c02
movl $0x1, 0x7c(%rsp)
movq 0xb8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0xa0(%rsp)
movl 0x7c(%rsp), %eax
movl 0x70(%rsp), %ecx
subl $0x2, %ecx
cmpl %ecx, %eax
jg 0x2495a
movq 0xa0(%rsp), %rax
movq 0x18(%rax), %rax
movq %rax, 0x58(%rsp)
movq 0x58(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, 0x50(%rsp)
movq 0x58(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, 0x48(%rsp)
movq 0x58(%rsp), %rax
movq 0x8(%rax), %rax
cmpl $0x0, 0x24(%rax)
je 0x24527
movq 0x58(%rsp), %rax
movl 0x18(%rax), %eax
movq 0x50(%rsp), %rcx
cmpl 0x18(%rcx), %eax
jge 0x244f1
movq 0xa8(%rsp), %rax
movq %rax, 0x20(%rsp)
movq 0x58(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0xc0(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0xa310
movq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0xbf70
jmp 0x24525
movq 0xa8(%rsp), %rax
movq %rax, 0x18(%rsp)
movq 0x58(%rsp), %rax
movq 0x8(%rax), %rdi
movq 0xc0(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0xa370
movq 0x18(%rsp), %rdi
movq %rax, %rsi
callq 0xbf70
jmp 0x24527
movq 0x58(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rax
cmpl $0x0, 0x24(%rax)
je 0x245c4
movq 0x58(%rsp), %rax
movl 0x18(%rax), %eax
movq 0x48(%rsp), %rcx
cmpl 0x18(%rcx), %eax
jge 0x2458a
movq 0xa8(%rsp), %rax
movq %rax, 0x10(%rsp)
movq 0x58(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
movq 0xc0(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0xa310
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0xbf70
jmp 0x245c2
movq 0xa8(%rsp), %rax
movq %rax, 0x8(%rsp)
movq 0x58(%rsp), %rax
movq 0x8(%rax), %rax
movq 0x8(%rax), %rdi
movq 0xc0(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0xa370
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0xbf70
jmp 0x245c4
movq 0xc0(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x1f310
movq %rax, 0x98(%rsp)
movq 0x50(%rsp), %rax
movl 0x18(%rax), %eax
movq 0x48(%rsp), %rcx
cmpl 0x18(%rcx), %eax
jge 0x2469f
movq 0x50(%rsp), %rcx
movq 0x98(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x48(%rsp), %rcx
movq 0x98(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0xa5a0
cmpb $0x0, %al
jne 0x2469a
movq 0x98(%rsp), %rdi
movq 0xc0(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0xa310
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
movl $0x1, 0x24(%rax)
movq 0x50(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0xa660
movq 0x98(%rsp), %rdi
movq 0xc0(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0xa370
movq %rax, 0x40(%rsp)
movq 0x40(%rsp), %rax
movl $0x1, 0x24(%rax)
movq 0x48(%rsp), %rdi
movq 0x40(%rsp), %rsi
callq 0xa660
jmp 0x24748
movq 0x48(%rsp), %rcx
movq 0x98(%rsp), %rax
movq %rcx, 0x10(%rax)
movq 0x50(%rsp), %rcx
movq 0x98(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0xa5a0
cmpb $0x0, %al
jne 0x24746
movq 0x98(%rsp), %rdi
movq 0xc0(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0xa310
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movl $0x1, 0x24(%rax)
movq 0x48(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0xa660
movq 0x98(%rsp), %rdi
movq 0xc0(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0xa370
movq %rax, 0x38(%rsp)
movq 0x38(%rsp), %rax
movl $0x1, 0x24(%rax)
movq 0x50(%rsp), %rdi
movq 0x38(%rsp), %rsi
callq 0xa660
jmp 0x24748
movq 0xb0(%rsp), %rdi
movq 0x98(%rsp), %rsi
callq 0xb610
movq 0x50(%rsp), %rdi
movq 0x58(%rsp), %rsi
movq 0xc0(%rsp), %rax
movq 0x10(%rax), %rdx
callq 0xa6a0
movq 0x50(%rsp), %rdi
callq 0xa600
cmpb $0x0, %al
je 0x247d5
movq 0x50(%rsp), %rax
cmpl $0x0, 0x28(%rax)
jne 0x247d3
movq 0xc0(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x1f310
movq %rax, 0x30(%rsp)
movq 0x50(%rsp), %rcx
movq 0x30(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0xb8(%rsp), %rdi
movq 0x30(%rsp), %rsi
callq 0xbf70
movq 0x50(%rsp), %rax
movl $0x1, 0x28(%rax)
jmp 0x247d5
movq 0x48(%rsp), %rdi
movq 0x58(%rsp), %rsi
movq 0xc0(%rsp), %rax
movq 0x10(%rax), %rdx
callq 0xa6a0
movq 0x48(%rsp), %rdi
callq 0xa600
cmpb $0x0, %al
je 0x2484d
movq 0x48(%rsp), %rax
cmpl $0x0, 0x28(%rax)
jne 0x2484b
movq 0xc0(%rsp), %rax
movq 0x10(%rax), %rdi
callq 0x1f310
movq %rax, 0x28(%rsp)
movq 0x48(%rsp), %rcx
movq 0x28(%rsp), %rax
movq %rcx, 0x18(%rax)
movq 0xb8(%rsp), %rdi
movq 0x28(%rsp), %rsi
callq 0xbf70
movq 0x48(%rsp), %rax
movl $0x1, 0x28(%rax)
jmp 0x2484d
movq 0xc0(%rsp), %rax
movq 0x10(%rax), %rdi
movq 0x58(%rsp), %rax
movq 0x8(%rax), %rsi
callq 0x1f460
movq 0x58(%rsp), %rax
movq $0x0, 0x8(%rax)
movq 0x50(%rsp), %rdi
movq 0x48(%rsp), %rsi
callq 0xa4d0
cmpl $0x1, %eax
jle 0x248d4
movq 0xc0(%rsp), %rdi
movq 0xb8(%rsp), %rsi
callq 0x1ff70
movq 0xc0(%rsp), %rdi
movq 0xb0(%rsp), %rsi
callq 0x1ff70
movq 0xc0(%rsp), %rdi
movq 0xa8(%rsp), %rsi
callq 0x1ff70
movb $0x0, 0xd7(%rsp)
jmp 0x24c02
movq 0xb8(%rsp), %rax
movl 0x10(%rax), %eax
subl 0x7c(%rsp), %eax
cmpl $0x2, %eax
jge 0x24934
movq 0xc0(%rsp), %rdi
movq 0xb8(%rsp), %rsi
callq 0x1ff70
movq 0xc0(%rsp), %rdi
movq 0xb0(%rsp), %rsi
callq 0x1ff70
movq 0xc0(%rsp), %rdi
movq 0xa8(%rsp), %rsi
callq 0x1ff70
movb $0x0, 0xd7(%rsp)
jmp 0x24c02
jmp 0x24936
movl 0x7c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x7c(%rsp)
movq 0xa0(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0xa0(%rsp)
jmp 0x2444e
movq 0xa8(%rsp), %rax
movq %rax, (%rsp)
movq 0x98(%rsp), %rdi
movq 0xc0(%rsp), %rax
movq 0x10(%rax), %rsi
callq 0xa310
movq (%rsp), %rdi
movq %rax, %rsi
callq 0xbf70
movq 0xa8(%rsp), %rax
movslq 0x10(%rax), %rdi
shlq $0x3, %rdi
callq 0x1170
movq %rax, 0x90(%rsp)
movl $0x0, 0x7c(%rsp)
movq 0xa8(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x80(%rsp)
movl 0x7c(%rsp), %eax
movq 0xa8(%rsp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x24a0e
movq 0x80(%rsp), %rdx
movq 0x90(%rsp), %rax
movslq 0x7c(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl 0x7c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x7c(%rsp)
movq 0x80(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x80(%rsp)
jmp 0x249c3
movq 0xb0(%rsp), %rax
movslq 0x10(%rax), %rdi
shlq $0x3, %rdi
callq 0x1170
movq %rax, 0x88(%rsp)
movl $0x0, 0x7c(%rsp)
movq 0xb0(%rsp), %rax
movq (%rax), %rax
movq %rax, 0x80(%rsp)
movl 0x7c(%rsp), %eax
movq 0xb0(%rsp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x24a91
movq 0x80(%rsp), %rdx
movq 0x88(%rsp), %rax
movslq 0x7c(%rsp), %rcx
movq %rdx, (%rax,%rcx,8)
movl 0x7c(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x7c(%rsp)
movq 0x80(%rsp), %rax
movq 0x8(%rax), %rax
movq %rax, 0x80(%rsp)
jmp 0x24a46
movq 0x88(%rsp), %rdi
movq 0xb0(%rsp), %rax
movslq 0x10(%rax), %rsi
movl $0x8, %edx
leaq -0x1e861(%rip), %rcx    # 0x6250
callq 0x1060
movq 0x90(%rsp), %rdi
movq 0xa8(%rsp), %rax
movslq 0x10(%rax), %rsi
movl $0x8, %edx
leaq -0x1e886(%rip), %rcx    # 0x6250
callq 0x1060
movl $0x0, 0x78(%rsp)
movl $0x0, 0x74(%rsp)
movb $0x1, 0x6f(%rsp)
movl 0x78(%rsp), %eax
movq 0xb0(%rsp), %rcx
cmpl 0x10(%rcx), %eax
jge 0x24b9e
jmp 0x24b07
movq 0x88(%rsp), %rdi
movslq 0x78(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq 0x90(%rsp), %rsi
movslq 0x74(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rsi
callq 0x6250
cmpl $0x0, %eax
jle 0x24b48
jmp 0x24b3b
movl 0x74(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x74(%rsp)
jmp 0x24b07
movq 0x88(%rsp), %rdi
movslq 0x78(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rdi
movq 0x90(%rsp), %rsi
movslq 0x74(%rsp), %rax
shlq $0x3, %rax
addq %rax, %rsi
callq 0x6250
cmpl $0x0, %eax
jne 0x24b87
movl 0x74(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x74(%rsp)
jmp 0x24b8e
movb $0x0, 0x6f(%rsp)
jmp 0x24b9e
movl 0x78(%rsp), %eax
addl $0x1, %eax
movl %eax, 0x78(%rsp)
jmp 0x24af0
movq 0xc0(%rsp), %rdi
movq 0xb8(%rsp), %rsi
callq 0x1ff70
movq 0xc0(%rsp), %rdi
movq 0xb0(%rsp), %rsi
callq 0x1ff70
movq 0xc0(%rsp), %rdi
movq 0xa8(%rsp), %rsi
callq 0x1ff70
movq 0x90(%rsp), %rdi
callq 0x1030
movq 0x88(%rsp), %rdi
callq 0x1030
movb 0x6f(%rsp), %al
movb %al, 0xd7(%rsp)
movb 0xd7(%rsp), %al
addq $0xd8, %rsp
retq
nopw %cs:(%rax,%rax)