// File: /workspace/github_c_makefile_star2_O2/pwelke[P]GraphMiningTools/cs_Outerplanar.c
// Function: _getCycleAndDiagonals
struct ShallowGraph* __getCycleAndDiagonals(struct Graph* g, struct ShallowGraphPool* sgp) {
	/* data structures described by Mitchell[1979] */
	struct ShallowGraph* list = getShallowGraph(sgp);
	struct ShallowGraph* pairs = getShallowGraph(sgp);
	struct ShallowGraph* edges = getGraphEdges(g, sgp);
	struct VertexList* node = NULL;
	struct VertexList* pair = NULL;
	/* data structures for canonical string computation */
	struct ShallowGraph* hamiltonianCycle = getShallowGraph(sgp);
	struct ShallowGraph* diagonals = getShallowGraph(sgp);
	/* data structures for sorting */
	struct VertexList** edgeArray;
	struct VertexList** pairArray;
	/* indices */
	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);
		dumpShallowGraph(sgp, hamiltonianCycle);
		dumpShallowGraph(sgp, diagonals);
		return NULL;
	}

	/* 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);
		dumpShallowGraph(sgp, hamiltonianCycle);
		dumpShallowGraph(sgp, diagonals);
		return NULL;
	}

	/*
	 * 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));
			}
		}

		/* canonical string: add the edges to hamiltonianCycle, if they are no triangulation
		 * edges (artificial or original!). Which is recorded in ->used */
		if (!v->neighborhood->used) {
			appendEdge(hamiltonianCycle, shallowCopyEdge(v->neighborhood, sgp->listPool));
		}
		if (!v->neighborhood->next->used) {
			appendEdge(hamiltonianCycle, shallowCopyEdge(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 {
				/* it the edge is an original edge of g, it is a diagonal and will be stored in
				 * diagonals (if that has not already been done). */
				for (idx=near->neighborhood; idx; idx=idx->next) {
					if (idx->endPoint == next) {
						if (!idx->flag && !idx->used) {
							appendEdge(diagonals, shallowCopyEdge(idx, sgp->listPool));
						}
						break;
					}
				}
			}
		} 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);
			} else {
				/* it the edge is an original edge of g, it is a diagonal and will be stored in
				 * diagonals (if that has not already been done). */
				for (idx=near->neighborhood; idx; idx=idx->next) {
					if (idx->endPoint == next) {
						if (!idx->flag && !idx->used) {
							appendEdge(diagonals, shallowCopyEdge(idx, sgp->listPool));
						}
						break;
					}
				}
			}
		}

		pushEdge(pairs, pair);

		/* canonical string: mark the new edge as triangulation edge via ->used */
		for (idx=near->neighborhood; idx; idx=idx->next) {
			if (idx->endPoint == next) {
				idx->used = 1;
			}
		}
		for (idx=next->neighborhood; idx; idx=idx->next) {
			if (idx->endPoint == near) {
				idx->used = 1;
			}
		}

		/* 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 the edges in
		 * hamiltonianCycle point to the vertices. We need them for the computation
		 * of the actual cycle. so 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);
			dumpShallowGraph(sgp, hamiltonianCycle);
			dumpShallowGraph(sgp, diagonals);
			return NULL;
		}



		/* 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);
			dumpShallowGraph(sgp, hamiltonianCycle);
			dumpShallowGraph(sgp, diagonals);
			return NULL;
		}
	}

	/* 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;
		}
	}

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

	/* create canonical string of this block or return NULL,
	 * if the block is not outerplanar */
	if (found) {
		struct VertexList* e;
		struct VertexList* lastEdge = NULL;

		/* delete all edges that remain in g. That is exactly one. Store one copy of it
		 * in case that this edge belongs to the hamiltonian cycle. */
		for (i=0; i<g->n; ++i) {
			if (g->vertices[i]->neighborhood) {
				dumpVertexListRecursively(sgp->listPool, lastEdge);
				lastEdge = g->vertices[i]->neighborhood;
				g->vertices[i]->neighborhood = NULL;
			}
		}

		/* add edges in hamiltonianCycle to g */
		while ((e = popEdge(hamiltonianCycle))) {
			e->next = e->startPoint->neighborhood;
			e->startPoint->neighborhood = e;

			e = inverseEdge(e, sgp->listPool);
			e->next = e->startPoint->neighborhood;
			e->startPoint->neighborhood = e;
		}

		/* hamiltonianCycle is now empty and g is a undirected cycle.
		 * Now obtain a ShallowGraph where edges are ordered correctly. */
		for (e=g->vertices[0]->neighborhood; e; e=e->endPoint->neighborhood) {

			/* remove e from the adjacency list of its startpoint */
			e->startPoint->neighborhood = e->next;
			e->next = NULL;

			/* remove inverse edge of e from adjacency list of e's endpoint
			 * remember: a vertex has exactly two neighbors except in the
			 * last iteration of this loop */
			if (e->endPoint->neighborhood->endPoint == e->startPoint) {
				struct VertexList* tmp = e->endPoint->neighborhood;
				e->endPoint->neighborhood = e->endPoint->neighborhood->next;
				dumpVertexList(sgp->listPool, tmp);
			} else {
				dumpVertexList(sgp->listPool, e->endPoint->neighborhood->next);
				e->endPoint->neighborhood->next = NULL;
			}

			/* add e to hamiltonianCycle */
			appendEdge(hamiltonianCycle, e);
		}

		/* in case the reducion phase of this algorithm reduced the last triangle
		 * onto an edge on the hamiltonian cycle of g, this edge is not yet contained
		 * in hamiltonianCycle. We have stored it in lastEdge. Add it. */
		if (hamiltonianCycle->edges->startPoint != hamiltonianCycle->lastEdge->endPoint) {
			if (hamiltonianCycle->lastEdge->endPoint == lastEdge->startPoint) {
				appendEdge(hamiltonianCycle, lastEdge);
			} else {
				appendEdge(hamiltonianCycle, inverseEdge(lastEdge, sgp->listPool));
				dumpVertexList(sgp->listPool, lastEdge);
			}
		} else {
			dumpVertexList(sgp->listPool, lastEdge);
		}

		/* special case:
		 * TODO needs theoretical background
		 * if diagonals contains exactly one edge, it may be the case that this edge is
		 * contained in the hamiltonian cycle and has to be removed.
		 * If so, this edge has been lastEdge above and is stored in
		 * hamiltonianCycle->lastEdge, we have to check for inverse edges, too. */
		if (diagonals->m == 1) {
			if ((diagonals->edges->startPoint == hamiltonianCycle->lastEdge->startPoint)
					&& (diagonals->edges->endPoint == hamiltonianCycle->lastEdge->endPoint)) {
				dumpVertexList(sgp->listPool, popEdge(diagonals));
			}
			if ((diagonals->edges->startPoint == hamiltonianCycle->lastEdge->endPoint)
					&& (diagonals->edges->endPoint == hamiltonianCycle->lastEdge->startPoint)) {
				dumpVertexList(sgp->listPool, popEdge(diagonals));
			}
		}

		/* now hamiltonianCycle is a cycle and
		 * diagonals contains the diagonals of the block. hurra! */
		hamiltonianCycle->next = diagonals;
		return hamiltonianCycle;


	} else {
		/* g is not outerplanar. return NULL. */
		dumpShallowGraph(sgp, hamiltonianCycle);
		dumpShallowGraph(sgp, diagonals);
		return NULL;
	}

	return NULL;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x48, %rsp
movq %rsi, %rbx
movq %rdi, %r12
movq %rsi, %rdi
callq 0x117e9
movq %rax, %rbp
movq %rbx, %rdi
callq 0x117e9
movq %rax, 0x18(%rsp)
movq %r12, %rdi
movq %rbx, %rsi
callq 0x6172
movq %rax, 0x8(%rsp)
movq %rbx, %rdi
callq 0x117e9
movq %rax, %r13
movq %rbx, %rdi
callq 0x117e9
movq %rax, 0x10(%rsp)
xorl %r15d, %r15d
xorl %r14d, %r14d
movslq (%r12), %rax
cmpq %rax, %r15
jge 0x480e
movq 0x10(%r12), %rax
movq (%rax,%r15,8), %rdi
testq %rdi, %rdi
je 0x4809
incl %r14d
callq 0x5b10
testb %al, %al
je 0x4809
movq 0x10(%rbx), %rdi
callq 0x11307
movq 0x10(%r12), %rcx
movq (%rcx,%r15,8), %rcx
movq %rcx, 0x18(%rax)
movq %rbp, %rdi
movq %rax, %rsi
callq 0x61e7
movq 0x10(%r12), %rax
movq (%rax,%r15,8), %rax
movl $0x1, 0x28(%rax)
incq %r15
jmp 0x47b5
leal -0x3(,%r14,2), %eax
cmpl %eax, 0x4(%r12)
jg 0x4823
cmpl $0x2, 0x10(%rbp)
jge 0x4875
movq %rbx, %rdi
movq %rbp, %rsi
callq 0x1184e
movq %rbx, %rdi
movq 0x18(%rsp), %rsi
callq 0x1184e
movq %rbx, %rdi
movq 0x8(%rsp), %rsi
callq 0x1184e
movq %rbx, %rdi
movq %r13, %rsi
callq 0x1184e
movq %rbx, %rdi
movq 0x10(%rsp), %rsi
callq 0x1184e
xorl %r13d, %r13d
movq %r13, %rax
addq $0x48, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
cmpl $0x3, %r14d
pushq $0x2
popq %rax
cmovgel %r14d, %eax
decl %eax
movl %eax, 0x44(%rsp)
pushq $0x1
popq %rcx
xorl %r15d, %r15d
movq %rbp, %rax
movq %rbp, 0x20(%rsp)
movq %r13, 0x28(%rsp)
cmpl 0x44(%rsp), %ecx
je 0x4b8e
movl %ecx, 0x30(%rsp)
movq (%rax), %rax
movq %rax, 0x38(%rsp)
movq 0x18(%rax), %r13
movq 0x8(%r13), %rdi
movq 0x8(%rdi), %rax
movq 0x18(%rdi), %rbp
movq 0x18(%rax), %r14
cmpl $0x0, 0x24(%rdi)
je 0x48ef
movl 0x18(%r13), %eax
movq 0x10(%rbx), %rsi
cmpl 0x18(%rbp), %eax
jge 0x48dd
callq 0x5a28
jmp 0x48e2
callq 0x5a44
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x6620
movq 0x8(%r13), %rax
movq 0x8(%rax), %rdi
cmpl $0x0, 0x24(%rdi)
je 0x4924
movl 0x18(%r13), %eax
movq 0x10(%rbx), %rsi
cmpl 0x18(%r14), %eax
jge 0x4912
callq 0x5a28
jmp 0x4917
callq 0x5a44
movq 0x8(%rsp), %rdi
movq %rax, %rsi
callq 0x6620
movq 0x8(%r13), %rdi
cmpl $0x0, 0x20(%rdi)
jne 0x4948
movq 0x10(%rbx), %rsi
callq 0x5a28
movq 0x28(%rsp), %rdi
movq %rax, %rsi
callq 0x6620
movq 0x8(%r13), %rdi
movq 0x8(%rdi), %rdi
cmpl $0x0, 0x20(%rdi)
jne 0x4968
movq 0x10(%rbx), %rsi
callq 0x5a28
movq 0x28(%rsp), %rdi
movq %rax, %rsi
callq 0x6620
movq 0x10(%rbx), %rdi
callq 0x11307
movq %rax, %r15
movl 0x18(%rbp), %eax
cmpl 0x18(%r14), %eax
jge 0x49ac
movq %rbp, 0x10(%r15)
movq %r14, 0x18(%r15)
movq %rbp, %rdi
movq %r14, %rsi
callq 0x5afb
movq %rbp, %rdi
testb %al, %al
je 0x4a05
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x4a73
cmpq %r14, 0x18(%rdi)
jne 0x4997
jmp 0x49d9
movq %r14, 0x10(%r15)
movq %rbp, 0x18(%r15)
movq %rbp, %rdi
movq %r14, %rsi
callq 0x5afb
movq %rbp, %rdi
testb %al, %al
je 0x4a39
movq 0x8(%rdi), %rdi
testq %rdi, %rdi
je 0x4a73
cmpq %r14, 0x18(%rdi)
jne 0x49c6
cmpl $0x0, 0x24(%rdi)
jne 0x4a73
cmpl $0x0, 0x20(%rdi)
jne 0x4a73
movq 0x10(%rbx), %rsi
callq 0x5a28
movq 0x10(%rsp), %rdi
movq %rax, %rsi
callq 0x6620
jmp 0x4a73
movq 0x10(%rbx), %rsi
movq %r15, %rdi
callq 0x5a28
pushq $0x1
popq %rcx
movl %ecx, 0x24(%rax)
movq %rbp, %rdi
movq %rax, %rsi
callq 0x5b2c
movq 0x10(%rbx), %rsi
movq %r15, %rdi
callq 0x5a44
pushq $0x1
popq %rcx
movl %ecx, 0x24(%rax)
movq %r14, %rdi
jmp 0x4a6b
movq 0x10(%rbx), %rsi
movq %r15, %rdi
callq 0x5a28
pushq $0x1
popq %rcx
movl %ecx, 0x24(%rax)
movq %r14, %rdi
movq %rax, %rsi
callq 0x5b2c
movq 0x10(%rbx), %rsi
movq %r15, %rdi
callq 0x5a44
pushq $0x1
popq %rcx
movl %ecx, 0x24(%rax)
movq %rbp, %rdi
movq %rax, %rsi
callq 0x5b2c
movq 0x18(%rsp), %rdi
movq %r15, %rsi
callq 0x61e7
movq %rbp, %rax
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x4a9b
cmpq %r14, 0x18(%rax)
jne 0x4a83
movl $0x1, 0x20(%rax)
jmp 0x4a83
movq %r14, %rax
movq 0x8(%rax), %rax
testq %rax, %rax
je 0x4ab6
cmpq %rbp, 0x18(%rax)
jne 0x4a9e
movl $0x1, 0x20(%rax)
jmp 0x4a9e
movq 0x10(%rbx), %rdx
movq %rbp, %rdi
movq %r13, %rsi
callq 0x5b39
movq %rbp, %rdi
callq 0x5b10
testb %al, %al
je 0x4af8
cmpl $0x0, 0x28(%rbp)
jne 0x4af8
movq 0x10(%rbx), %rdi
callq 0x11307
movq %rbp, 0x18(%rax)
movq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0x6620
movl $0x1, 0x28(%rbp)
movq 0x10(%rbx), %rdx
movq %r14, %rdi
movq %r13, %rsi
callq 0x5b39
movq %r14, %rdi
callq 0x5b10
testb %al, %al
je 0x4b3c
cmpl $0x0, 0x28(%r14)
jne 0x4b3c
movq 0x10(%rbx), %rdi
callq 0x11307
movq %r14, 0x18(%rax)
movq 0x20(%rsp), %rdi
movq %rax, %rsi
callq 0x6620
movl $0x1, 0x28(%r14)
movq 0x10(%rbx), %rdi
movq 0x8(%r13), %rsi
callq 0x1138e
andq $0x0, 0x8(%r13)
movq %rbp, %rdi
movq %r14, %rsi
callq 0x5aae
cmpl $0x2, %eax
jge 0x4cc0
movq 0x20(%rsp), %rsi
movl 0x10(%rsi), %eax
movl 0x30(%rsp), %ecx
subl %ecx, %eax
cmpl $0x1, %eax
movq 0x28(%rsp), %r13
jle 0x4cec
incl %ecx
movq 0x38(%rsp), %rax
addq $0x8, %rax
jmp 0x4899
movq 0x10(%rbx), %rsi
movq %r15, %rdi
callq 0x5a28
movq 0x8(%rsp), %r15
movq %r15, %rdi
movq %rax, %rsi
callq 0x6620
movslq 0x10(%r15), %r14
movq %r14, %rdi
shlq $0x3, %rdi
callq 0x1180
xorl %esi, %esi
testl %r14d, %r14d
movl $0x0, %ecx
cmovgl %r14d, %ecx
cmpq %rsi, %rcx
je 0x4bdd
movq (%r15), %r15
movq %r15, (%rax,%rsi,8)
incq %rsi
addq $0x8, %r15
jmp 0x4bc8
movq %rax, 0x30(%rsp)
movq 0x18(%rsp), %r14
movslq 0x10(%r14), %r13
leaq (,%r13,8), %rdi
callq 0x1180
xorl %esi, %esi
testl %r13d, %r13d
movl $0x0, %ecx
cmovgl %r13d, %ecx
movq %r14, %rdx
cmpq %rsi, %rcx
je 0x4c1e
movq (%rdx), %rdx
movq %rdx, (%rax,%rsi,8)
incq %rsi
addq $0x8, %rdx
jmp 0x4c09
leaq -0x1135(%rip), %r14     # 0x3af0
pushq $0x8
popq %rbp
movq %rax, 0x38(%rsp)
movq %rax, %rdi
movq %r13, %rsi
movq %rbp, %rdx
movq %r14, %rcx
callq 0x1080
movq 0x8(%rsp), %rax
movslq 0x10(%rax), %rsi
movq 0x30(%rsp), %rdi
movq %rbp, %rdx
movq 0x20(%rsp), %r13
movq %r14, %rcx
callq 0x1080
xorl %r14d, %r14d
xorl %r15d, %r15d
movq 0x18(%rsp), %rax
movslq 0x10(%rax), %rax
cmpq %rax, %r14
jge 0x4cf4
movq 0x38(%rsp), %rax
leaq (%rax,%r14,8), %r13
movslq %r15d, %r15
movq 0x30(%rsp), %rax
leaq (%rax,%r15,8), %rbp
movq %r13, %rdi
movq %rbp, %rsi
callq 0x3af0
incq %r15
addq $0x8, %rbp
testl %eax, %eax
jg 0x4c89
addq $-0x8, %rbp
movq %r13, %rdi
movq %rbp, %rsi
callq 0x3af0
testl %eax, %eax
jne 0x4e62
incq %r14
movq 0x20(%rsp), %r13
jmp 0x4c62
movq %rbx, %rdi
movq 0x20(%rsp), %rsi
callq 0x1184e
movq %rbx, %rdi
movq 0x18(%rsp), %rsi
callq 0x1184e
movq %rbx, %rdi
movq 0x8(%rsp), %rsi
callq 0x1184e
jmp 0x4e9d
movq %rbx, %rdi
jmp 0x4829
movq %rbx, %rdi
movq %r13, %rsi
callq 0x1184e
movq %rbx, %rdi
movq 0x18(%rsp), %rsi
callq 0x1184e
movq %rbx, %rdi
movq 0x8(%rsp), %rsi
callq 0x1184e
movq 0x30(%rsp), %rdi
callq 0x1030
movq 0x38(%rsp), %rdi
callq 0x1030
xorl %r15d, %r15d
xorl %r14d, %r14d
movq 0x28(%rsp), %r13
movslq (%r12), %rax
cmpq %rax, %r15
jge 0x4da0
movq 0x10(%r12), %rax
movq (%rax,%r15,8), %rax
cmpq $0x0, 0x8(%rax)
je 0x4d6f
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x1138e
movq 0x10(%r12), %rax
movq (%rax,%r15,8), %rax
movq 0x8(%rax), %r14
andq $0x0, 0x8(%rax)
incq %r15
jmp 0x4d38
movq 0x10(%rax), %rcx
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq %rax, 0x8(%rcx)
movq 0x10(%rbx), %rsi
movq %rax, %rdi
callq 0x5a44
movq 0x10(%rax), %rcx
movq 0x8(%rcx), %rdx
movq %rdx, 0x8(%rax)
movq %rax, 0x8(%rcx)
movq %r13, %rdi
callq 0x65fe
testq %rax, %rax
jne 0x4d74
movq 0x10(%r12), %r12
movq (%r12), %rax
movq 0x8(%rax), %r15
testq %r15, %r15
je 0x4e1c
movq 0x8(%r15), %rax
movq 0x10(%r15), %rcx
movq %rax, 0x8(%rcx)
andq $0x0, 0x8(%r15)
leaq 0x18(%r15), %r12
movq 0x18(%r15), %rax
movq 0x8(%rax), %rsi
cmpq %rcx, 0x18(%rsi)
je 0x4dfe
movq 0x10(%rbx), %rdi
movq 0x8(%rsi), %rsi
callq 0x11364
movq (%r12), %rax
movq 0x8(%rax), %rax
andq $0x0, 0x8(%rax)
jmp 0x4e0f
movq 0x8(%rsi), %rcx
movq %rcx, 0x8(%rax)
movq 0x10(%rbx), %rdi
callq 0x11364
movq %r13, %rdi
movq %r15, %rsi
callq 0x6620
jmp 0x4db2
movq (%r13), %rcx
movq 0x8(%r13), %rax
movq 0x18(%rax), %rax
cmpq %rax, 0x10(%rcx)
je 0x4eaa
cmpq 0x10(%r14), %rax
movq 0x10(%rsp), %r15
je 0x4ebd
movq 0x10(%rbx), %rsi
movq %r14, %rdi
callq 0x5a44
movq %r13, %rdi
movq %rax, %rsi
callq 0x6620
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x11364
jmp 0x4ec8
movq %rbx, %rdi
movq 0x20(%rsp), %rsi
callq 0x1184e
movq %rbx, %rdi
movq 0x18(%rsp), %rsi
callq 0x1184e
movq %rbx, %rdi
movq 0x8(%rsp), %rsi
callq 0x1184e
movq 0x30(%rsp), %rdi
callq 0x1030
movq 0x38(%rsp), %rdi
callq 0x1030
movq %rbx, %rdi
movq 0x28(%rsp), %rsi
jmp 0x484e
movq 0x10(%rbx), %rdi
movq %r14, %rsi
callq 0x11364
movq 0x10(%rsp), %r15
jmp 0x4ec8
movq %r13, %rdi
movq %r14, %rsi
callq 0x6620
cmpl $0x1, 0x10(%r15)
jne 0x4f33
movq (%r15), %rax
movq 0x10(%rax), %rdx
movq 0x8(%r13), %rcx
cmpq 0x10(%rcx), %rdx
jne 0x4f0c
movq 0x18(%rax), %rsi
cmpq 0x18(%rcx), %rsi
jne 0x4f0c
movq 0x10(%rbx), %r14
movq %r15, %rdi
callq 0x65fe
movq %r14, %rdi
movq %rax, %rsi
callq 0x11364
movq (%r15), %rax
movq 0x10(%rax), %rdx
movq 0x8(%r13), %rcx
cmpq 0x18(%rcx), %rdx
jne 0x4f33
movq 0x18(%rax), %rax
cmpq 0x10(%rcx), %rax
jne 0x4f33
movq 0x10(%rbx), %rbx
movq %r15, %rdi
callq 0x65fe
movq %rbx, %rdi
movq %rax, %rsi
callq 0x11364
movq %r15, 0x18(%r13)
jmp 0x4863