// File: /workspace/github_c_makefile_star2_O2/mishun[P]plantri/plantri.c
// Function: scanmin5c
static void
scanmin5c(int nbtot, int nbop, int dosplit, EDGE **prevA, int nprevA)

/* The main node of the recursion for 5-connected triangulations.
   As this procedure is entered, nv,ne,degree etc are set for some graph,
   and nbtot/nbop are the values returned by canon() for that graph.
   If dosplit==TRUE, this is the place to do splitting (if any).
   prev[0..nprevA-1] is the list of consecutive A operations leading
   to this graph, given by their central edges.
   If nprevA == 0, this graph wasn't made with A.
*/
{
    EDGE *firstedge_save[MAXN];
    EDGE *extA1[MAXN*MAXN/4+10],*extA2[MAXN*MAXN/4+10],
         *extB[MAXE],*extC[MAXN];
    EDGE *extAred,*extBred,*extCred,*extCanchor;
    int extBmirror[MAXE];
    EDGE *good_or[MAXE],*good_mir[MAXE];
    EDGE *newprevA[MAXN];
    int ngood_or,ngood_mir,ngood_ref,ngood_mir_ref;
    int nextA,nextB,nextC,i,j;
    int xnbtot,xnbop;
    int colour[MAXN];

    if (nv == maxnv)
    {
        got_one(nbtot,nbop,5);
	return;
    }

    if (dosplit)
    {
#ifdef SPLITTEST
        ADDBIG(splitcases,1);
        return;
#endif
        if (splitcount-- != 0) return;
        splitcount = mod - 1;

        for (i = 0; i < nv; ++i) firstedge_save[i] = firstedge[i];
    }

#ifdef PRE_FILTER_MIN5
    if (!(PRE_FILTER_MIN5)) return;
#endif

#ifndef FIND_EXTENSIONS_MIN5
#define FIND_EXTENSIONS_MIN5 find_extensions_min5
#endif

    FIND_EXTENSIONS_MIN5(nbtot,nbop,extA1,extA2,&nextA,extB,extBmirror,
          &nextB,extC,&nextC,(nprevA==0?NULL:prevA[nprevA-1]));

    if (nextA > MAXN*MAXN/4)
    {
	fprintf(stderr,">E Increase the array bounds for extA1 and\n");
	fprintf(stderr,"   extA2 in scanmin5() and scanmin5c().\n");
	exit(1);
    }

    for (i = 0; i < nextA; ++i)
    {
        extAred = extend_min5_a(extA1[i],extA2[i]);
#ifdef FAST_FILTER_MIN5
        if (FAST_FILTER_MIN5)
#endif 
        {
	    min5_a_legal(extAred,good_or,&ngood_or,&ngood_ref,
		         good_mir,&ngood_mir,&ngood_mir_ref,prevA,nprevA);

            if (ngood_ref+ngood_mir_ref > 0)
	    {
	        if (nv == maxnv && !needgroup && ngood_or == ngood_ref
                                              && ngood_mir == ngood_mir_ref)
	        {
		    got_one(1,1,5);
	        }
	        else if (ngood_or+ngood_mir==1)
	        {
		    prevA[nprevA] = extAred;
    		    scanmin5c(1,1,nv==splitlevel,prevA,nprevA+1);
	        }
	        else if (canon_edge_oriented(good_or,ngood_or,ngood_ref,
                                           good_mir,ngood_mir,ngood_mir_ref,
                                           degree,numbering,&xnbtot,&xnbop))
	        {
                    prevA[nprevA] = extAred;
	            scanmin5c(xnbtot,xnbop,nv==splitlevel,prevA,nprevA+1);
	        }
	    }
	}
	reduce_min5_a(extAred);
    }

    for (i = 0; i < nextB; ++i)
    {
        extBred = extend_min5_b(extB[i],extBmirror[i]);
#ifdef FAST_FILTER_MIN5
        if (FAST_FILTER_MIN5)
#endif  
        {
            if (!has_min5_a())
	    {
                min5_b_legal(extBred,extBmirror[i],good_or,&ngood_or,
			     &ngood_ref,good_mir,&ngood_mir,&ngood_mir_ref);
    
                if (ngood_ref+ngood_mir_ref > 0)
                {
                    if (canon_edge_oriented(good_or,ngood_or,ngood_ref,
                                            good_mir,ngood_mir,ngood_mir_ref,
                                            degree,numbering,&xnbtot,&xnbop))
                        scanmin5c(xnbtot,xnbop,
                                  nv==splitlevel||nv==splitlevel+1,newprevA,0);
	        }
	    }
	}
        reduce_min5_b(extBred,extBmirror[i]);
    }

    for (i = 0; i < nextC; ++i)
    {
        extCred = extend_min5_c(extC[i],&extCanchor);
#ifdef FAST_FILTER_MIN5
        if (FAST_FILTER_MIN5)
#endif  
        {
            if (!has_min5_a() && !has_min5_b())
            {
	        for (j = 0; j < nv-1; ++j)
		    if (is_min5_c_centre(j)) colour[j] = 2;
		    else                     colour[j] = degree[j];
	        colour[nv-1] = 2;
    
                if (canon(colour,numbering,&xnbtot,&xnbop)) 
                    scanmin5c(xnbtot,xnbop,
                              nv>=splitlevel&&nv<=splitlevel+4,newprevA,0);
            }
        }
        reduce_min5_c(extCred,extCanchor);
    }

    if (dosplit)
        for (i = 0; i < nv; ++i) firstedge[i] = firstedge_save[i];
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x70a8, %rsp           # imm = 0x70A8
movl 0x2254a7(%rip), %eax    # 0x242600
cmpl 0x7101(%rip), %eax      # 0x24260
jne 0x1d17a
pushq $0x5
popq %rdx
addq $0x70a8, %rsp           # imm = 0x70A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
jmp 0x658a
movl %r8d, %r15d
movq %rcx, %r12
testl %edx, %edx
je 0x1d1c8
subl $0x1, 0x26ba85(%rip)    # 0x288c10
jae 0x1d5db
movl 0x70c5(%rip), %ecx      # 0x2425c
decl %ecx
movl %ecx, 0x26ba71(%rip)    # 0x288c10
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
shlq $0x3, %rax
leaq 0x882f(%rip), %r9       # 0x259e0
cmpq %rcx, %rax
je 0x1d1c8
movq (%rcx,%r9), %r8
movq %r8, 0x550(%rsp,%rcx)
addq $0x8, %rcx
jmp 0x1d1b1
movslq %r15d, %rax
testl %r15d, %r15d
movl %edx, 0x34(%rsp)
movq %rax, 0x28(%rsp)
je 0x1d1e0
movq -0x8(%r12,%rax,8), %rax
jmp 0x1d1e2
xorl %eax, %eax
subq $0x8, %rsp
leaq 0x40(%rsp), %r10
leaq 0x358(%rsp), %r11
leaq 0x44(%rsp), %r14
leaq 0x758(%rsp), %r13
leaq 0x5058(%rsp), %rdx
leaq 0x3008(%rsp), %rcx
leaq 0x54(%rsp), %rbx
leaq 0x2468(%rsp), %r9
movq %rbx, %r8
pushq %rax
pushq %r10
pushq %r11
pushq %r14
pushq %r13
callq 0x11548
addq $0x30, %rsp
movl (%rbx), %ebp
cmpl $0x400, %ebp            # imm = 0x400
jg 0x1d5ed
xorl %r13d, %r13d
testl %ebp, %ebp
cmovlel %r13d, %ebp
leal 0x1(%r15), %eax
movl %eax, 0x20(%rsp)
leaq 0x18c0(%rsp), %r14
cmpq %r13, %rbp
je 0x1d394
movq 0x5050(%rsp,%r13,8), %rdi
movq 0x3000(%rsp,%r13,8), %rsi
callq 0x11c72
movq %rax, %rbx
subq $0x8, %rsp
movq %rax, %rdi
leaq 0xd28(%rsp), %rsi
leaq 0x24(%rsp), %rdx
leaq 0x1c(%rsp), %rcx
movq %r14, %r8
leaq 0x20(%rsp), %r9
pushq %r15
pushq %r12
leaq 0x28(%rsp), %rax
pushq %rax
callq 0x11df2
addq $0x20, %rsp
movl 0x14(%rsp), %edx
movl 0x10(%rsp), %r9d
movl %r9d, %eax
addl %edx, %eax
jle 0x1d384
movl 0x225338(%rip), %eax    # 0x242600
movl 0x6f92(%rip), %ecx      # 0x24260
xorl %eax, %ecx
orl 0x86fa(%rip), %ecx      # 0x259d0
movl 0x1c(%rsp), %esi
movl %esi, %edi
xorl %edx, %edi
orl %ecx, %edi
movl 0x18(%rsp), %r8d
movl %r8d, %ecx
xorl %r9d, %ecx
orl %edi, %ecx
jne 0x1d301
pushq $0x1
popq %rdi
movl %edi, %esi
pushq $0x5
popq %rdx
callq 0x658a
jmp 0x1d384
leal (%r8,%rsi), %ecx
cmpl $0x1, %ecx
jne 0x1d325
movq 0x28(%rsp), %rcx
movq %rbx, (%r12,%rcx,8)
xorl %edx, %edx
cmpl 0x86b9(%rip), %eax      # 0x259d4
sete %dl
pushq $0x1
popq %rdi
movl %edi, %esi
jmp 0x1d377
subq $0x8, %rsp
leaq 0xd28(%rsp), %rdi
movq %r14, %rcx
leaq 0x10(%rsp), %rax
pushq %rax
leaq 0x1c(%rsp), %rax
pushq %rax
leaq 0x8899(%rip), %rax      # 0x25be0
pushq %rax
callq 0xb886
addq $0x20, %rsp
testl %eax, %eax
je 0x1d384
movq 0x28(%rsp), %rax
movq %rbx, (%r12,%rax,8)
movl 0xc(%rsp), %edi
movl 0x8(%rsp), %esi
movl 0x225294(%rip), %eax    # 0x242600
xorl %edx, %edx
cmpl 0x8660(%rip), %eax      # 0x259d4
sete %dl
movq %r12, %rcx
movl 0x20(%rsp), %r8d
callq 0x1d142
movq %rbx, %rdi
callq 0x1248d
incq %r13
jmp 0x1d259
movl 0x3c(%rsp), %r14d
xorl %r15d, %r15d
testl %r14d, %r14d
cmovlel %r15d, %r14d
leaq 0xd20(%rsp), %rbx
leaq 0x18c0(%rsp), %r12
cmpq %r15, %r14
je 0x1d494
movq 0x2460(%rsp,%r15,8), %rdi
movl 0x750(%rsp,%r15,4), %ebp
movl %ebp, %esi
callq 0x12561
movq %rax, %r13
callq 0x127dc
testl %eax, %eax
je 0x1d3ee
movq %r13, %rdi
movl %ebp, %esi
callq 0x12a42
incq %r15
jmp 0x1d3b3
movq %r13, %rdi
movl %ebp, %esi
movq %rbx, %rdx
leaq 0x1c(%rsp), %rcx
leaq 0x14(%rsp), %r8
movq %r12, %r9
leaq 0x10(%rsp), %rax
pushq %rax
leaq 0x20(%rsp), %rax
pushq %rax
callq 0x12861
popq %rax
popq %rcx
movl 0x14(%rsp), %edx
movl 0x10(%rsp), %r9d
movl %r9d, %eax
addl %edx, %eax
jle 0x1d3df
movl 0x1c(%rsp), %esi
movl 0x18(%rsp), %r8d
subq $0x8, %rsp
movq %rbx, %rdi
movq %r12, %rcx
leaq 0x10(%rsp), %rax
pushq %rax
leaq 0x1c(%rsp), %rax
pushq %rax
leaq 0x8794(%rip), %rax      # 0x25be0
pushq %rax
callq 0xb886
addq $0x20, %rsp
testl %eax, %eax
je 0x1d3df
movl 0xc(%rsp), %edi
movl 0x8(%rsp), %esi
movl 0x225198(%rip), %eax    # 0x242600
movl 0x8566(%rip), %ecx      # 0x259d4
cmpl %ecx, %eax
sete %dl
incl %ecx
cmpl %ecx, %eax
sete %al
orb %dl, %al
movzbl %al, %edx
leaq 0x150(%rsp), %rcx
xorl %r8d, %r8d
callq 0x1d142
jmp 0x1d3df
movl 0x38(%rsp), %ebx
xorl %eax, %eax
testl %ebx, %ebx
cmovlel %eax, %ebx
leaq 0x40(%rsp), %r14
pushq $0x2
popq %r12
xorl %r15d, %r15d
movq %rbx, 0x20(%rsp)
cmpq %rbx, %r15
je 0x1d5a5
movq 0x350(%rsp,%r15,8), %rdi
movq %r14, %rsi
callq 0x12b7a
movq %rax, %rbp
callq 0x127dc
testl %eax, %eax
jne 0x1d590
callq 0x12e47
testl %eax, %eax
jne 0x1d590
movslq 0x225113(%rip), %rax    # 0x242600
movq %rax, 0x28(%rsp)
leal -0x1(%rax), %ebx
testl %ebx, %ebx
movl $0x0, %eax
cmovlel %eax, %ebx
leaq 0x86da(%rip), %r14      # 0x25be0
xorl %r13d, %r13d
cmpq %r13, %rbx
je 0x1d52e
movl %r13d, %edi
callq 0x12eee
movl %r12d, %ecx
testl %eax, %eax
jne 0x1d520
movl (%r14), %ecx
movl %ecx, 0x50(%rsp,%r13,4)
incq %r13
addq $0x4, %r14
jmp 0x1d509
movq 0x28(%rsp), %r13
movl $0x2, 0x4c(%rsp,%r13,4)
leaq 0x50(%rsp), %rdi
leaq 0xc(%rsp), %rsi
leaq 0x8(%rsp), %rdx
callq 0x52ed
testl %eax, %eax
movq 0x20(%rsp), %rbx
leaq 0x40(%rsp), %r14
je 0x1d590
movl 0xc(%rsp), %edi
movl 0x8(%rsp), %esi
movl 0x8468(%rip), %eax      # 0x259d4
cmpl %eax, %r13d
setge %cl
addl $0x4, %eax
cmpl %eax, %r13d
setle %al
andb %cl, %al
movzbl %al, %edx
leaq 0x150(%rsp), %rcx
xorl %r8d, %r8d
callq 0x1d142
movq 0x40(%rsp), %rsi
movq %rbp, %rdi
callq 0x12fda
incq %r15
jmp 0x1d4b0
cmpl $0x0, 0x34(%rsp)
je 0x1d5db
movl 0x22504e(%rip), %eax    # 0x242600
xorl %ecx, %ecx
testl %eax, %eax
cmovlel %ecx, %eax
shlq $0x3, %rax
leaq 0x841c(%rip), %rdx      # 0x259e0
cmpq %rcx, %rax
je 0x1d5db
movq 0x550(%rsp,%rcx), %rsi
movq %rsi, (%rcx,%rdx)
addq $0x8, %rcx
jmp 0x1d5c4
addq $0x70a8, %rsp           # imm = 0x70A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0x6a04(%rip), %r14      # 0x23ff8
movq (%r14), %rcx
leaq 0x10b8(%rip), %rdi      # 0x1e6b6
pushq $0x2b
popq %rsi
pushq $0x1
popq %rbx
movq %rbx, %rdx
callq 0x10c0
movq (%r14), %rcx
leaq 0x10cc(%rip), %rdi      # 0x1e6e2
pushq $0x28
popq %rsi
movq %rbx, %rdx
callq 0x10c0
pushq $0x1
popq %rdi
callq 0x10b0