LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/mishun[P]plantri/plantri.c
// Function: make_me_a_star
static void
make_me_a_star(int n)

/* Makes a star on n vertices -- so one vertex of degree n-1
   and n-1 vertices of degree 1 */
{
   int i;
   EDGE *buffer, *buffer2;

   if (n==1) { nv=1; ne=0; firstedge[0]=NULL; return; }

   firstedge[0]=edges;
   degree[0]=n-1;
   for (i=1, buffer=edges, buffer2=edges+n-1;
	i<=n-1;i++,buffer++,buffer2++)
     { buffer->start=buffer2->end=0;
       buffer->end=buffer2->start=i;
       buffer->invers=buffer2;
       buffer2->invers=buffer;
       buffer->min=buffer2->min=buffer;
       buffer2->prev=buffer2->next=buffer2;
       degree[i]=1;
       firstedge[i]=buffer2;
     }
   
   buffer=edges; /* buffer leading to 1 */
   if (n>2) buffer->next=buffer+1; else buffer->next=buffer;
   buffer->prev=buffer+n-2;
   for (i=2,buffer++; i<n-1; i++, buffer++) /* buffer leading to i */
     { buffer->prev=buffer-1;
       buffer->next=buffer+1;
     }
   if (n>2) /* buffer leading to n-1 */
     {
       buffer->prev=buffer-1;
       buffer->next=edges;
     }

    nv=n;
    ne=2*(n-1);
}

// Assembly:
cmpl $0x1, %edi
jne 0x74dc
movl $0x1, 0x23d14a(%rip)    # 0x244610
movl $0x0, 0x23d144(%rip)    # 0x244614
movq $0x0, 0x20515(%rip) # 0x279f0
retq
leaq 0x23d13d(%rip), %rdx    # 0x244620
movq %rdx, 0x20506(%rip)     # 0x279f0
leal -0x1(%rdi), %eax
movl %eax, 0x206fd(%rip)     # 0x27bf0
movslq %edi, %r8
shlq $0x6, %r8
leaq (%rdx,%r8), %rcx
cmpl $0x1, %edi
jle 0x75fb
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
movl %edi, %esi
leaq -0x8(,%rsi,8), %rsi
addq %rdx, %r8
addq $-0x3c, %r8
movl $0x1, %r9d
xorl %r10d, %r10d
leaq 0x206c1(%rip), %r11     # 0x27bf0
leaq 0x204ba(%rip), %rbx     # 0x279f0
xorl %r14d, %r14d
movq %rdx, %r15
leaq (%r8,%r14,8), %r12
addq $-0x4, %r12
movl %r10d, 0x4(%r12)
movl %r10d, (%rdx,%r14,8)
movl %r9d, (%r12)
movl %r9d, 0x4(%rdx,%r14,8)
movq %r12, 0x20(%rdx,%r14,8)
movq %r15, 0x20(%r12)
movq %r15, 0x28(%r12)
movq %r15, 0x28(%rdx,%r14,8)
movq %r12, 0x18(%r12)
movq %r12, 0x10(%r12)
movl $0x1, (%r11,%r9,4)
movq %r12, 0x8(%r14,%rbx)
incq %r9
addq $0x40, %r15
addq $0x8, %r14
cmpq %r14, %rsi
jne 0x753c
cmpl $0x2, %edi
leaq 0x23d085(%rip), %rdx    # 0x244620
leaq 0x23d0be(%rip), %rsi    # 0x244660
movq %rsi, %r8
cmoveq %rdx, %r8
movq %r8, 0x23d088(%rip)     # 0x244638
addq $-0x80, %rcx
movq %rcx, 0x23d075(%rip)    # 0x244630
cmpl $0x4, %edi
jl 0x75e1
leal -0x3(%rdi), %ecx
leaq 0x23d096(%rip), %r8     # 0x244660
leaq -0x40(%r8), %rsi
movq %rsi, 0x10(%r8)
leaq 0x40(%r8), %rsi
movq %rsi, 0x18(%r8)
movq %rsi, %r8
decl %ecx
jne 0x75ca
cmpl $0x2, %edi
je 0x75f2
leaq -0x40(%rsi), %rcx
movq %rcx, 0x10(%rsi)
movq %rdx, 0x18(%rsi)
popq %rbx
popq %r12
popq %r14
popq %r15
jmp 0x760d
movq %rdx, 0x23d036(%rip)    # 0x244638
addq $-0x80, %rcx
movq %rcx, 0x23d023(%rip)    # 0x244630
movl %edi, 0x23cffd(%rip)    # 0x244610
addl %eax, %eax
movl %eax, 0x23cff9(%rip)    # 0x244614
retq
// File: /workspace/github_c_makefile_star2_O3/mishun[P]plantri/plantri.c
// Function: write_planar_code
static void
write_planar_code(FILE *f, int doflip)   

/* Write in planar_code format.  Always write in next direction,
   and if doflip != 0 also write in prev direction. */
{
    size_t length;
    unsigned char code[MAXN+MAXE+1];
    
    length=nv+ne+1;
    compute_code(code);
    if (fwrite(code,sizeof(unsigned char),length,f) != length)
    {
        fprintf(stderr,">E %s: fwrite() failed\n",cmdname);
        perror(">E ");
        exit(1);
    }
    if (doflip)
      { compute_code_mirror(code);
        if (fwrite(code,sizeof(unsigned char),length,f) != length)
	  {
	    fprintf(stderr,">E %s: fwrite() failed\n",cmdname);
	    perror(">E ");
	    exit(1);
	  }
      }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1b8, %rsp            # imm = 0x1B8
movl %esi, %ebp
movq %rdi, %rbx
movl 0x23961f(%rip), %eax    # 0x244610
movl 0x23961d(%rip), %ecx    # 0x244614
leal 0x1(%rax,%rcx), %eax
movslq %eax, %r14
movq %rsp, %r15
movq %r15, %rdi
callq 0xb0f1
movl $0x1, %esi
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x10e0
cmpq %r14, %rax
jne 0xb056
testl %ebp, %ebp
je 0xb048
movq %rsp, %r15
movq %r15, %rdi
callq 0xb236
movl $0x1, %esi
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x10e0
cmpq %r14, %rax
jne 0xb05b
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x267e
callq 0x26b2
// File: /workspace/github_c_makefile_star2_O3/mishun[P]plantri/plantri.c
// Function: write_dual_planar_code
static void
write_dual_planar_code(FILE *f, int doflip)   

/* Write the dual in planar_code format.  Always write in next direction,
   and if doflip != 0 also write in prev direction. */
{
    size_t length;
    unsigned char code[MAXF+MAXE+1];
    
    length=3+ne+(ne/2)-nv;
    compute_dual_code(code);
    if (fwrite(code,sizeof(unsigned char),length,f) != length)
    {
        fprintf(stderr,">E %s: fwrite() failed\n",cmdname);
        perror(">E ");
        exit(1);
    }
    if (doflip)
      { compute_dual_code_mirror(code);
      if (fwrite(code,sizeof(unsigned char),length,f) != length)
	{
	  fprintf(stderr,">E %s: fwrite() failed\n",cmdname);
	  perror(">E ");
	  exit(1);
	}
      }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x1f8, %rsp            # imm = 0x1F8
movl %esi, %ebp
movq %rdi, %rbx
movl 0x23959c(%rip), %eax    # 0x244614
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
subl 0x239587(%rip), %ecx    # 0x244610
addl $0x3, %ecx
movslq %ecx, %r14
movq %rsp, %r15
movq %r15, %rdi
callq 0xb37f
movl $0x1, %esi
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x10e0
cmpq %r14, %rax
jne 0xb0e7
testl %ebp, %ebp
je 0xb0d9
movq %rsp, %r15
movq %r15, %rdi
callq 0xb52d
movl $0x1, %esi
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x10e0
cmpq %r14, %rax
jne 0xb0ec
addq $0x1f8, %rsp            # imm = 0x1F8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x26e6
callq 0x271a
// File: /workspace/github_c_makefile_star2_O3/mishun[P]plantri/plantri.c
// Function: startbipscan
static void
startbipscan(int nbtot, int nbop, int conn)

/* This routine begins the scan for general connected bipartite planar graphs
 * formed by removing edges from quadrangulations.  The current graph is
 * a quadrangulation, and the group is known (parameters nbtot,nbop).
 * conn is the connectivity (2 or 3, must be correct).
 */

{
    EDGE *feasible[MAXE/2];
    EDGE *e,*ex;
    int i,j,nfeas;

    for (i = 0; i < nv; ++i)
    {
	for (j = 0; j < nv; ++j) am2[i][j] = 0;
	am2[i][i] = 1;
    }

    nfeas = 0;
    for (i = 0; i < nv; ++i)
    {
        e = ex = firstedge[i];
        do
        {
            if (e == e->min && degree[e->start] > minpolydeg
                            && degree[e->end] > minpolydeg)
                feasible[nfeas++] = e;
            e->left_facesize = 4;
            am2[e->start][e->end] = 1;
            e = e->next;
        } while (e != ex);
    }

    prune_bip_edgelist(feasible,nfeas,feasible,&nfeas);

    scanbip(nbtot,nbop,feasible,nfeas,4,0,0,conn);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x5e8, %rsp            # imm = 0x5E8
movl %edx, %r13d
movl %esi, %ebp
movl %edi, %r14d
movslq 0x237f81(%rip), %r15    # 0x244610
testq %r15, %r15
jle 0xc75f
movl %r14d, 0x4(%rsp)
movl %ebp, 0x8(%rsp)
movq %r13, %r14
movq %r15, %r12
shlq $0x6, %r12
leaq 0x27e68e(%rip), %rbp    # 0x28ad40
xorl %ebx, %ebx
movq %rbp, %r13
leaq (%rbx,%rbp), %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x1030
movb $0x1, (%r13)
addq $0x41, %r13
addq $0x40, %rbx
cmpq %rbx, %r12
jne 0xc6b7
testl %r15d, %r15d
jle 0xc763
xorl %eax, %eax
movl 0x19ab8(%rip), %ecx     # 0x261a0
leaq 0x1b301(%rip), %rdx     # 0x279f0
leaq 0x1b4fa(%rip), %rdi     # 0x27bf0
leaq 0x27e643(%rip), %r8     # 0x28ad40
xorl %esi, %esi
movq %r14, %r13
movl 0x8(%rsp), %ebp
movl 0x4(%rsp), %r14d
movq (%rdx,%rax,8), %r9
movq %r9, %r10
movslq (%r10), %r11
cmpq 0x28(%r10), %r10
jne 0xc734
cmpl %ecx, (%rdi,%r11,4)
jle 0xc734
movslq 0x4(%r10), %rbx
cmpl %ecx, (%rdi,%rbx,4)
jle 0xc734
movslq %esi, %rbx
incl %esi
movq %r10, 0x10(%rsp,%rbx,8)
movl $0x4, 0x38(%r10)
movslq 0x4(%r10), %rbx
shlq $0x6, %r11
addq %r8, %r11
movb $0x1, (%rbx,%r11)
movq 0x18(%r10), %r10
cmpq %r9, %r10
jne 0xc712
incq %rax
cmpq %r15, %rax
jne 0xc70b
jmp 0xc771
xorl %esi, %esi
jmp 0xc771
xorl %esi, %esi
movq %r14, %r13
movl 0x8(%rsp), %ebp
movl 0x4(%rsp), %r14d
leaq 0xc(%rsp), %r15
movl %esi, (%r15)
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq %r12, %rdx
movq %r15, %rcx
callq 0xcd78
movl (%r15), %ecx
movl %r14d, %edi
movl %ebp, %esi
movq %r12, %rdx
movl $0x4, %r8d
xorl %r9d, %r9d
pushq %r13
pushq $0x0
callq 0xcdd6
addq $0x5f8, %rsp            # imm = 0x5F8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mishun[P]plantri/plantri.c
// Function: reduce_quadr_P1
static void
reduce_quadr_P1(EDGE *e)

/* reduces a graph previously extended by the type P1 extension for
   3-connected quadrangulations. The edge e must be the reference edge
*/

{
  register EDGE *e1, *e1i, *e2, *e3, *e3i, *e4;
  int end1, end2, center, end;

  nv--; ne-=4;

  end=e->end;
  e2=e->prev->invers->prev;
  end1=e2->start;
  e1i=e2->next->next;
  e1=e1i->invers;
  center=e1->start;
  e3=e1->next;
  e3i=e3->invers;
  e4=e3i->next->next;
  end2=e4->start;

  e2->next=e1i; e1i->prev=e2; firstedge[end1]=e2; degree[end1]--;
  e1->next=e; e->prev=e1; e->next=e3; e3->prev=e; 
  e->start=e->invers->end=center; degree[center]++;
  e3i->next=e4; e4->prev=e3i; firstedge[end2]=e4; degree[end2]--;
}

// Assembly:
pushq %r14
pushq %rbx
decl 0x23791f(%rip)          # 0x244610
addl $-0x4, 0x23791c(%rip)   # 0x244614
movq 0x10(%rdi), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rax
movslq (%rax), %rcx
movq 0x18(%rax), %rdx
movq 0x18(%rdx), %rdx
movq 0x20(%rdx), %rsi
movslq (%rsi), %r8
movq 0x18(%rsi), %r9
movq 0x20(%r9), %r10
movq 0x18(%r10), %r11
movq 0x18(%r11), %r11
movslq (%r11), %rbx
movq %rdx, 0x18(%rax)
movq %rax, 0x10(%rdx)
leaq 0x1aeb8(%rip), %rdx     # 0x27bf0
decl (%rdx,%rcx,4)
leaq 0x1acae(%rip), %r14     # 0x279f0
movq %rax, (%r14,%rcx,8)
movq %rdi, 0x18(%rsi)
movq %rsi, 0x10(%rdi)
movq %r9, 0x18(%rdi)
movq %rdi, 0x10(%r9)
movq 0x20(%rdi), %rax
movl %r8d, 0x4(%rax)
movl %r8d, (%rdi)
incl (%rdx,%r8,4)
movq %r11, 0x18(%r10)
movq %r10, 0x10(%r11)
movq %r11, (%r14,%rbx,8)
decl (%rdx,%rbx,4)
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/mishun[P]plantri/plantri.c
// Function: prune_bip_edgelist
static void
prune_bip_edgelist(EDGE *old[], int numold, EDGE *newe[], int *numnew)

/* Copy from old[0..numold-1] to newe[0..*numnew-1] each edge e with
 *    these two properties:
 *       1. Both ends of e have degree >= minpolydeg+1.
 *          2. e is contained in a 4-face.
 *            It is legal that old and newe and &numold and numnew are the same.
 */

{
    int i,counter=0;
    EDGE *e;

    for (i=0; i<numold; i++, old++)
      { e = *old; 
        if (degree[e->start] > minpolydeg && degree[e->end] > minpolydeg
             && (e->left_facesize == 4 || e->invers->left_facesize == 4))
            newe[counter++]=e;
      }

    *numnew=counter;
}

// Assembly:
testl %esi, %esi
jle 0xcdcf
pushq %rbx
movl 0x1941d(%rip), %eax     # 0x261a0
movl %esi, %esi
xorl %r9d, %r9d
leaq 0x1ae61(%rip), %r10     # 0x27bf0
xorl %r8d, %r8d
movq (%rdi,%r9,8), %r11
movslq (%r11), %rbx
cmpl %eax, (%r10,%rbx,4)
jle 0xcdc4
movslq 0x4(%r11), %rbx
cmpl %eax, (%r10,%rbx,4)
jle 0xcdc4
cmpl $0x4, 0x38(%r11)
je 0xcdba
movq 0x20(%r11), %rbx
cmpl $0x4, 0x38(%rbx)
jne 0xcdc4
movslq %r8d, %rbx
incl %r8d
movq %r11, (%rdx,%rbx,8)
incq %r9
cmpl %r9d, %esi
jne 0xcd92
popq %rbx
jmp 0xcdd2
xorl %r8d, %r8d
movl %r8d, (%rcx)
retq
// File: /workspace/github_c_makefile_star2_O3/mishun[P]plantri/plantri.c
// Function: insert_edge_general
static void
insert_edge_general(EDGE *e)

/* inserts the edge previously deleted -- e may not have been modified in
   the meantime and the map must look exactly like it looked before deleting
   it. There is no special face size required on the left hand side of e */
{
    int newfacesize;
    EDGE *run;

    ne +=2;

    e->prev->next=e;
    e->next->prev=e;
    (degree[e->start])++;

    e=e->invers;

    e->prev->next=e;
    e->next->prev=e;
    (degree[e->start])++;

    run=e->prev->invers;
        /* now the face on the right of e when entering this function is
           on the left of run */
    newfacesize=e->left_facesize;

    for (run=e->prev->invers; run != e; run=run->prev->invers)
        run->left_facesize=newfacesize;

    e=e->invers; /* back to the old */
    run=e->prev->invers;
    newfacesize=e->left_facesize;
    for (run=e->prev->invers; run != e; run=run->prev->invers)
        run->left_facesize=newfacesize;

}

// Assembly:
addl $0x2, 0x2361f6(%rip)    # 0x244614
movq 0x10(%rdi), %rax
movq %rdi, 0x18(%rax)
movq 0x18(%rdi), %rax
movq %rdi, 0x10(%rax)
movslq (%rdi), %rax
leaq 0x197b8(%rip), %rcx     # 0x27bf0
incl (%rcx,%rax,4)
movq 0x20(%rdi), %rax
movq 0x10(%rax), %rdx
movq %rax, 0x18(%rdx)
movq 0x18(%rax), %rdx
movq %rax, 0x10(%rdx)
movslq (%rax), %rdx
incl (%rcx,%rdx,4)
movq 0x10(%rax), %rcx
movq 0x20(%rcx), %rcx
cmpq %rax, %rcx
je 0xe475
movl 0x38(%rax), %edx
movl %edx, 0x38(%rcx)
movq 0x10(%rcx), %rcx
movq 0x20(%rcx), %rcx
cmpq %rax, %rcx
jne 0xe465
movq 0x20(%rax), %rax
movq 0x10(%rax), %rcx
movq 0x20(%rcx), %rcx
cmpq %rax, %rcx
je 0xe499
movl 0x38(%rax), %edx
movl %edx, 0x38(%rcx)
movq 0x10(%rcx), %rcx
movq 0x20(%rcx), %rcx
cmpq %rax, %rcx
jne 0xe489
retq
// File: /workspace/github_c_makefile_star2_O3/mishun[P]plantri/plantri.c
// Function: extend_quadr_P2
static EDGE
*extend_quadr_P2(EDGE *e)

/* extends a graph in the way given by the type P2 extension for
   3-connected quadrangulations. 

   It returns the directed edge characterizing this operation.
*/

{
  register EDGE *e1, *e2, *e3, *e4, *e5, *e5i, *e6i, *start, *dummy;
  int end1, end2, end3, center;

  center=e->start;
  e=e->next;
  end2=e->end;
  e1=e->invers;
  e4=e1->next;
  e5=e1->prev;
  e5i=e5->invers;
  e6i=e5i->prev;
  end3=e5i->start;
  e3=e4->invers->next->invers;
  e2=e3->next;
  end1=e3->start;

  start=quadr_P2(nv);
  dummy=start+1;
  start->end=dummy->start=end3; degree[end3]++;
  e6i->next=e5i->prev=dummy; dummy->prev=e6i; dummy->next=e5i;

  dummy=start+3;
  dummy->start=(dummy-1)->end=end2; firstedge[end2]=dummy;
  e5->next=e4->prev=dummy; dummy->next=e4; dummy->prev=e5;

  dummy=start+5;
  dummy->start=(dummy-1)->end=end1; degree[end1]++;
  e3->next=e2->prev=dummy; dummy->next=e2; dummy->prev=e3;

  dummy=start+7;
  e->end=e1->start=nv;
  start->next=dummy->prev=e1; e1->next=dummy; e1->prev=start;

  degree[nv]=degree[nv+1]=3;
  firstedge[nv]=start; firstedge[nv+1]=start+2;

  nv+=2; ne+=8;

  return start;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %r11
movslq 0x4(%rdi), %r10
movq 0x20(%rdi), %rcx
movq 0x10(%rcx), %rdi
movq 0x18(%rcx), %rbx
movq 0x20(%rdi), %r12
movq 0x10(%r12), %r13
movslq (%r12), %rbp
movq 0x20(%rbx), %rdx
movq 0x18(%rdx), %rdx
movq 0x20(%rdx), %r9
movq 0x18(%r9), %rax
movq %rax, -0x8(%rsp)
movslq (%r9), %rax
movslq 0x235fb7(%rip), %rdx    # 0x244610
movq %rdx, %rsi
shlq $0x9, %rsi
leaq 0x235fb9(%rip), %r14    # 0x244620
leaq (%rsi,%r14), %r15
addq $0x3140, %r15           # imm = 0x3140
movl %ebp, (%r15)
leaq 0x19574(%rip), %r8      # 0x27bf0
incl (%r8,%rbp,4)
movl %ebp, -0x3c(%r15)
movq %r15, 0x10(%r12)
movq %r15, 0x18(%r13)
movq %r13, 0x10(%r15)
movq %r12, 0x18(%r15)
leaq 0x31c0(%rsi,%r14), %r12
movl %r10d, -0x3c(%r12)
movl %r10d, (%r12)
leaq 0x19343(%rip), %r13     # 0x279f0
movq %r12, (%r13,%r10,8)
movq %r12, 0x10(%rbx)
movq %r12, 0x18(%rdi)
movq %rbx, 0x18(%r12)
movq %rdi, 0x10(%r12)
leaq (%rsi,%r14), %rdi
addq $0x3240, %rdi           # imm = 0x3240
movl %eax, -0x3c(%rdi)
movl %eax, (%rdi)
incl (%r8,%rax,4)
movq -0x8(%rsp), %rax
movq %rdi, 0x10(%rax)
movq %rdi, 0x18(%r9)
movq %rax, 0x18(%rdi)
movq %r9, 0x10(%rdi)
movl %edx, (%rcx)
movl %edx, 0x4(%r11)
leaq 0x32c0(%rsi,%r14), %rax
movq %rcx, 0x10(%rax)
movq %rcx, -0x28(%r15)
movq %rax, 0x18(%rcx)
leaq 0x3100(%rsi,%r14), %rax
movq %rax, 0x10(%rcx)
movl $0x3, %ecx
movl %ecx, 0x4(%r8,%rdx,4)
movl %ecx, (%r8,%rdx,4)
leaq 0x3180(%rsi,%r14), %rcx
movq %rax, (%r13,%rdx,8)
movq %rcx, 0x8(%r13,%rdx,8)
leal 0x2(%rdx), %ecx
movl %ecx, 0x235ed4(%rip)    # 0x244610
addl $0x8, 0x235ed1(%rip)    # 0x244614
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mishun[P]plantri/plantri.c
// Function: reduce_quadr_P2
static void
reduce_quadr_P2(EDGE *e)

/* reduces a P2 configuration formerly expanded by extend_quadr_P2() */

{  register EDGE *e1, *e2, *e3, *e4, *e5, *e5i, *e6i;
   int end1, end2, end3, center;

   nv-=2; ne-=8;

   e1=e->next;
   e=e->invers;
   end3=e->start;
   e6i=e->prev; e5i=e->next;
   e5=e5i->invers;
   end2=e5->start;
   e4=e5->next->next;
   e3=e4->invers->next->invers;
   end1=e3->start;
   e2=e3->next->next;
   e=e1->invers;
   center=e1->end;

   e6i->next=e5i; e5i->prev=e6i; degree[end3]--; firstedge[end3]=e5i;

   e5->next=e4->prev=e1; e1->next=e4; e1->prev=e5; 
   e1->start=e->end=end2; firstedge[end2]=e1;

   e3->next=e2; e2->prev=e3; degree[end1]--; firstedge[end1]=e2;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
addl $-0x2, 0x235eb6(%rip)   # 0x244610
addl $-0x8, 0x235eb3(%rip)   # 0x244614
movslq (%rsi), %rax
movq 0x10(%rsi), %rcx
movq 0x18(%rsi), %rdx
movq 0x20(%rdx), %rsi
movslq (%rsi), %r8
movq 0x18(%rsi), %r9
movq 0x18(%r9), %r9
movq 0x20(%r9), %r10
movq 0x18(%r10), %r10
movq 0x20(%r10), %r10
movslq (%r10), %r11
movq 0x18(%r10), %rbx
movq 0x18(%rbx), %rbx
movq 0x20(%rdi), %r14
movq %rdx, 0x18(%rcx)
movq %rcx, 0x10(%rdx)
leaq 0x1944b(%rip), %rcx     # 0x27bf0
decl (%rcx,%rax,4)
leaq 0x19241(%rip), %r15     # 0x279f0
movq %rdx, (%r15,%rax,8)
movq %rdi, 0x10(%r9)
movq %rdi, 0x18(%rsi)
movq %r9, 0x18(%rdi)
movq %rsi, 0x10(%rdi)
movl %r8d, 0x4(%r14)
movl %r8d, (%rdi)
movq %rdi, (%r15,%r8,8)
movq %rbx, 0x18(%r10)
movq %r10, 0x10(%rbx)
decl (%rcx,%r11,4)
movq %rbx, (%r15,%r11,8)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/mishun[P]plantri/plantri.c
// Function: reduce_quadr_P3
static void
reduce_quadr_P3(EDGE *e)

/* Reduces the graph formerly extended by the type P3 extension for
   3-connected quadrangulations. That is: It removes a square on the
   right hand side of e.
*/

{
  register EDGE *dummy;
  int start;

  nv-=4; ne-=16;

  dummy=e->next->next;
  start=e->start;
  degree[start]--; firstedge[start]=e;
  e->next=dummy; dummy->prev=e;

  e=dummy->invers;
  dummy=e->next->next;
  start=e->start;
  degree[start]--; firstedge[start]=e;
  e->next=dummy; dummy->prev=e;

  e=dummy->invers;
  dummy=e->next->next;
  start=e->start;
  degree[start]--; firstedge[start]=e;
  e->next=dummy; dummy->prev=e;

  e=dummy->invers;
  dummy=e->next->next;
  start=e->start;
  degree[start]--; firstedge[start]=e;
  e->next=dummy; dummy->prev=e;
}

// Assembly:
addl $-0x4, 0x235cd4(%rip)   # 0x244610
addl $-0x10, 0x235cd1(%rip)  # 0x244614
movq 0x18(%rdi), %rax
movq 0x18(%rax), %rax
movslq (%rdi), %rcx
leaq 0x1929b(%rip), %rdx     # 0x27bf0
decl (%rdx,%rcx,4)
leaq 0x19091(%rip), %rsi     # 0x279f0
movq %rdi, (%rsi,%rcx,8)
movq %rax, 0x18(%rdi)
movq %rdi, 0x10(%rax)
movq 0x20(%rax), %rax
movq 0x18(%rax), %rcx
movq 0x18(%rcx), %rcx
movslq (%rax), %rdi
decl (%rdx,%rdi,4)
movq %rax, (%rsi,%rdi,8)
movq %rcx, 0x18(%rax)
movq %rax, 0x10(%rcx)
movq 0x20(%rcx), %rax
movq 0x18(%rax), %rcx
movq 0x18(%rcx), %rcx
movslq (%rax), %rdi
decl (%rdx,%rdi,4)
movq %rax, (%rsi,%rdi,8)
movq %rcx, 0x18(%rax)
movq %rax, 0x10(%rcx)
movq 0x20(%rcx), %rax
movq 0x18(%rax), %rcx
movq 0x18(%rcx), %rcx
movslq (%rax), %rdi
decl (%rdx,%rdi,4)
movq %rax, (%rsi,%rdi,8)
movq %rcx, 0x18(%rax)
movq %rax, 0x10(%rcx)
retq
// File: /workspace/github_c_makefile_star2_O3/mishun[P]plantri/plantri.c
// Function: legal_P3_reduction
static int
legal_P3_reduction(EDGE *e)

/* checks whether the edge corresponds to a legal P3 reduction.
   Returns 1 if it is a legal reduction, 0 else. 

   Again it is assumed (necessary or not) that P1 has higher priority
   -- the nonexistence of a P1 reduction forces some subconfiguration.

   Furthermore it is assumed that the graph inspected is not the cube.
*/

{
  EDGE *run, *last;
  int v1,v2;

  if (degree[e->next->end]!=3) return 0;
  run=e->invers->prev;
  if (degree[run->end]!=3) return 0;
  run=run->prev->invers->prev;  
  if (degree[run->end]!=3) return 0;
  v1=run->start;
   run=run->prev->invers->prev;  
  if (degree[run->end]!=3) return 0;
  v2=run->start;
 
  /* OK -- we have an "inserted square" on the right hand side */

  /* Test whether opposite vertices share a face */

  last=e->prev;
  run=e->next->next->next;
  while (run!=last)
    { if (run->invers->prev->end==v1) return 0;
    run=run->next; }

  e=e->invers;
  last=e->prev->prev->prev;
  run=e->next;
  while (run!=last)
    { if (run->invers->prev->end==v2) return 0;
    run=run->next; }

  return 1;
}

// Assembly:
movq 0x18(%rdi), %rsi
movslq 0x4(%rsi), %rcx
leaq 0x1913f(%rip), %r8      # 0x27bf0
xorl %eax, %eax
cmpl $0x3, (%r8,%rcx,4)
jne 0xeb41
movq 0x20(%rdi), %rcx
movq 0x10(%rcx), %rdx
movslq 0x4(%rdx), %r9
cmpl $0x3, (%r8,%r9,4)
jne 0xeb41
movq 0x10(%rdx), %rdx
movq 0x20(%rdx), %r9
movq 0x10(%r9), %r9
movslq 0x4(%r9), %r10
cmpl $0x3, (%r8,%r10,4)
jne 0xeb41
movq 0x10(%r9), %r10
movq 0x20(%r10), %r10
movq 0x10(%r10), %r10
movslq 0x4(%r10), %r11
cmpl $0x3, (%r8,%r11,4)
jne 0xeb41
movl (%r9), %r9d
movl (%r10), %r8d
movq 0x10(%rdi), %rdi
movq 0x18(%rsi), %rsi
movq 0x18(%rsi), %rsi
cmpq %rdi, %rsi
je 0xeb26
movq 0x20(%rsi), %r10
movq 0x10(%r10), %r10
cmpl %r9d, 0x4(%r10)
jne 0xeb0d
jmp 0xeb41
movq 0x10(%rdx), %rdx
movq 0x18(%rcx), %rcx
cmpq %rdx, %rcx
je 0xeb42
movq 0x20(%rcx), %rsi
movq 0x10(%rsi), %rsi
cmpl %r8d, 0x4(%rsi)
jne 0xeb2a
retq
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mishun[P]plantri/plantri.c
// Function: all_5_bangles
static void
all_5_bangles(EDGE **bang, int *nbang)

/* Set bang[0..nbang-1] to the central edges (min) of all bangles.
   5-connected case. */

{
    int i,nb;
    EDGE *e,*elast;

    nb = 0;
    for (i = 0; i < nv; ++i)
    {
	e = elast = firstedge[i];
	do
	{
	    if (e == e->min && is_in_5_bangle(e)) bang[nb++] = e;
	    e = e->next;
	} while (e != elast);
    }

    *nbang = nb;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movq %rsi, (%rsp)
cmpl $0x0, 0x234834(%rip)    # 0x244610
jle 0xfe2a
movq %rdi, %r14
xorl %r12d, %r12d
leaq 0x17c05(%rip), %r13     # 0x279f0
xorl %ebp, %ebp
movq (%r13,%r12,8), %rbx
movq %rbx, %r15
cmpq 0x28(%r15), %r15
jne 0xfe10
movq %r15, %rdi
callq 0x123ea
testl %eax, %eax
je 0xfe10
movslq %ebp, %rax
incl %ebp
movq %r15, (%r14,%rax,8)
movq 0x18(%r15), %r15
cmpq %rbx, %r15
jne 0xfdf5
incq %r12
movslq 0x2347ed(%rip), %rax    # 0x244610
cmpq %rax, %r12
jl 0xfded
jmp 0xfe2c
xorl %ebp, %ebp
movq (%rsp), %rax
movl %ebp, (%rax)
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mishun[P]plantri/plantri.c
// Function: make_cycle
static void
make_cycle(int n)

/* Makes a cycle on n vertices and uses the first 2n edges of the
   vector edges[] for it. Interpretation: a 1-cycle is a loop,
   a 2-cycle a double-edge. */

{
   int i, end;
   EDGE *buffer, *bufferb;

   /* edges+2*i always leads from i to i+1 (mod n) and edges+2*i+1
      leads back. */

   for (i=0;i<=n-1;i++)
     { end=(i+1)%n;
     degree[i]=2;
     buffer=edges+(2*i);
     firstedge[i]=buffer;
     bufferb=buffer+1;
     buffer->invers=bufferb;
     bufferb->invers=buffer;
     buffer->min=bufferb->min=buffer;
     buffer->start=bufferb->end=i;
     bufferb->start=buffer->end=end;
     if (i>0) buffer->prev=buffer->next=buffer-1;
     else buffer->prev=buffer->next=edges+2*n-1;
     if (i<n-1) bufferb->prev=bufferb->next=bufferb+1;
     else bufferb->prev=bufferb->next=edges;
     }

   nv=n; ne=2*n;

   return;
}

// Assembly:
pushq %rbp
pushq %rbx
xorl %eax, %eax
leaq 0x156db(%rip), %rcx     # 0x279f0
leaq 0x158d4(%rip), %rsi     # 0x27bf0
leaq 0x2322fd(%rip), %rdx    # 0x244620
leaq 0x232436(%rip), %rdi    # 0x244760
movl $0x80, %r8d
xorl %r10d, %r10d
xorl %r9d, %r9d
leaq (%rdx,%r9), %r11
leaq (%r9,%rdx), %rbx
addq $0x40, %rbx
movq %rbx, -0x20(%rbx)
movq %r11, 0x20(%rbx)
movq %r11, 0x28(%rbx)
movq %r11, -0x18(%rbx)
movl %r10d, 0x4(%rbx)
movl %r10d, -0x40(%rbx)
incl %r10d
cmpq $0x100, %r9             # imm = 0x100
movl %r10d, %ebp
cmovel %eax, %ebp
movl $0x2, (%rsi)
movq %r11, (%rcx)
movl %ebp, -0x3c(%rbx)
movl %ebp, (%rbx)
testq %r9, %r9
je 0x12398
leaq (%r9,%rdx), %rbx
addq $-0x40, %rbx
movq %rbx, 0x58(%rbx)
movq %rbx, 0x50(%rbx)
cmpq $0x100, %r9             # imm = 0x100
jne 0x123a2
jmp 0x123c9
movq %rdi, 0x18(%r9,%rdx)
movq %rdi, 0x10(%r9,%rdx)
addq %r8, %r11
movq %r11, 0x58(%r9,%rdx)
movq %r11, 0x50(%r9,%rdx)
addq %r8, %r9
addq $0x8, %rcx
addq $0x4, %rsi
cmpq $0x180, %r9             # imm = 0x180
jne 0x12336
jmp 0x123d3
movq %rdx, 0x58(%r9,%rdx)
movq %rdx, 0x50(%r9,%rdx)
movl $0x3, 0x232233(%rip)    # 0x244610
movl $0x6, 0x23222d(%rip)    # 0x244614
popq %rbx
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mishun[P]plantri/plantri.c
// Function: is_in_5_bangle
static int
is_in_5_bangle(EDGE *e)

/* Test if e is the central edge of a bangle, 5-connected case. */

{
    EDGE *e1,*e2;
    int k,l;

    RESETMARKS_V;
    for (e1 = e->prev->invers->next->next, k = degree[e->prev->end]-4;
                                                 --k >= 0; e1 = e1->next)
        MARK_V(e1->end);

    for (e1 = e->next->invers->prev->prev, k = degree[e->next->end]-4;
                                                 --k >= 0; e1 = e1->prev)
        for (e2 = e1->invers->next->next, l = degree[e1->end]-3;
                                                 --l >= 0; e2 = e2->next)
            if (ISMARKED_V(e2->end)) return TRUE;

    return FALSE;
}

// Assembly:
pushq %rbx
movq %rdi, %rbx
movl 0x13c9c(%rip), %eax     # 0x26090
leal 0x1(%rax), %ecx
movl %ecx, 0x13c93(%rip)     # 0x26090
cmpl $0x7530, %eax           # imm = 0x7530
jl 0x12426
movl $0x1, 0x13c82(%rip)     # 0x26090
leaq 0x27881b(%rip), %rdi    # 0x28ac30
movl $0x100, %edx            # imm = 0x100
xorl %esi, %esi
callq 0x1030
movl $0x1, %ecx
movq 0x10(%rbx), %rdi
movslq 0x4(%rdi), %rax
leaq 0x157bb(%rip), %rdx     # 0x27bf0
movl (%rdx,%rax,4), %eax
leaq 0x2787f1(%rip), %rsi    # 0x28ac30
cmpl $0x5, %eax
jl 0x12462
movq 0x20(%rdi), %rdi
movq 0x18(%rdi), %rdi
addl $-0x3, %eax
movq 0x18(%rdi), %rdi
movslq 0x4(%rdi), %r8
movl %ecx, (%rsi,%r8,4)
decl %eax
cmpl $0x1, %eax
ja 0x1244f
movq 0x18(%rbx), %r8
movslq 0x4(%r8), %rax
movl (%rdx,%rax,4), %edi
xorl %eax, %eax
cmpl $0x5, %edi
jl 0x124c1
addl $-0x5, %edi
movq 0x20(%r8), %r8
movq 0x10(%r8), %r8
movq 0x10(%r8), %r8
movq 0x20(%r8), %r9
movq 0x18(%r9), %r9
movslq 0x4(%r8), %r10
movl (%rdx,%r10,4), %r10d
addl $-0x2, %r10d
decl %r10d
testl %r10d, %r10d
jle 0x124af
movq 0x18(%r9), %r9
movslq 0x4(%r9), %r11
cmpl %ecx, (%rsi,%r11,4)
jne 0x12497
jmp 0x124bc
leal -0x1(%rdi), %r9d
testl %edi, %edi
movl %r9d, %edi
jg 0x1247f
jmp 0x124c1
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O3/mishun[P]plantri/plantri.c
// Function: reduce_min5_a
static void
reduce_min5_a(EDGE *e)

/* reduces the graph previously extended by the type a extension for
   5-connected triangulations if the edge returned by the function is
   given as a parameter.
*/

{
  register EDGE *e1, *e2, *e3, *e4, *e1i, *e2i, *work1, *work2, *run;
  int end1, end2, center, counter;

  e1=e->prev;
  e2=e->next;
  e1i=e1->invers;
  e2i=e2->invers;
  work1=e1i->prev->prev;
  work2=e2i->next->next;

  e=e->invers;
  e3=e->next->next;
  e4=e->prev->prev;
  center=e1->start;
  end1=e1->end;
  end2=e2->end;

  firstedge[center]=e1;
  firstedge[end1]=e1i;
  firstedge[end2]=e2i;

  counter=1; run=e3; run->start=run->invers->end=center;
  do { run=run->next; run->start=run->invers->end=center; counter++; }
  while (run != e4);

  degree[center]+=(counter-1);
  degree[end1]--;
  degree[end2]--;

  e1->next=e3; e3->prev=e1;
  e2->prev=e4; e4->next=e2;

  e1i->prev=work1; work1->next=e1i;
  e2i->next=work2; work2->prev=e2i;

  nv--; ne-=6;

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x10(%rdi), %rsi
movq 0x18(%rdi), %rdx
movq 0x20(%rsi), %rcx
movq 0x20(%rdx), %rax
movq 0x10(%rcx), %r8
movq 0x10(%r8), %r8
movq 0x18(%rax), %r9
movq 0x18(%r9), %r9
movq 0x20(%rdi), %rdi
movq 0x10(%rdi), %r11
movq 0x18(%rdi), %rdi
movq 0x18(%rdi), %r10
movq 0x10(%r11), %rdi
movl (%rsi), %ebp
movslq 0x4(%rsi), %r11
movslq 0x4(%rdx), %rbx
movslq %ebp, %r14
leaq 0x140c9(%rip), %r15     # 0x279f0
movq %rsi, (%r15,%r14,8)
movq %rcx, (%r15,%r11,8)
movq %rax, (%r15,%rbx,8)
movq 0x20(%r10), %r15
movl %r14d, 0x4(%r15)
movl %r14d, (%r10)
xorl %r15d, %r15d
movq %r10, %r12
movq 0x18(%r12), %r12
movq 0x20(%r12), %r13
movl %ebp, 0x4(%r13)
movl %ebp, (%r12)
incl %r15d
cmpq %rdi, %r12
jne 0x13944
leaq 0x1428b(%rip), %r12     # 0x27bf0
addl %r15d, (%r12,%r14,4)
decl (%r12,%r11,4)
decl (%r12,%rbx,4)
movq %r10, 0x18(%rsi)
movq %rsi, 0x10(%r10)
movq %rdi, 0x10(%rdx)
movq %rdx, 0x18(%rdi)
movq %r8, 0x10(%rcx)
movq %rcx, 0x18(%r8)
movq %r9, 0x18(%rax)
movq %rax, 0x10(%r9)
decl 0x230c79(%rip)          # 0x244610
addl $-0x6, 0x230c76(%rip)   # 0x244614
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mishun[P]plantri/plantri.c
// Function: has_min5_a
static int
has_min5_a(void)

/* Test if the graph has an A-reduction */

{
    EDGE *e,*elast;
    int i;

    for (i = 0; i < nv; ++i)
    {
        e = elast = firstedge[i];
        do
        {
            if (e == e->min && degree[e->next->end] >= 6
                    && degree[e->prev->end] >= 6 && !on_nf_5_cycle(e))
                return TRUE;
            e = e->next;
        } while (e != elast);
    }

    return FALSE;
}

// Assembly:
cmpl $0x0, 0x2309e1(%rip)    # 0x244610
jle 0x13cad
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
xorl %r14d, %r14d
leaq 0x13dac(%rip), %r15     # 0x279f0
leaq 0x13fa5(%rip), %r12     # 0x27bf0
movq (%r15,%r14,8), %r13
movq %r13, %rbx
cmpq 0x28(%rbx), %rbx
jne 0x13c82
movq 0x18(%rbx), %rax
movslq 0x4(%rax), %rax
cmpl $0x6, (%r12,%rax,4)
jl 0x13c82
movq 0x10(%rbx), %rax
movslq 0x4(%rax), %rax
cmpl $0x6, (%r12,%rax,4)
jl 0x13c82
movq %rbx, %rdi
callq 0x184cf
testl %eax, %eax
je 0x13c9e
movq 0x18(%rbx), %rbx
cmpq %r13, %rbx
jne 0x13c52
incq %r14
movslq 0x23097b(%rip), %rax    # 0x244610
cmpq %rax, %r14
jl 0x13c4b
xorl %eax, %eax
jmp 0x13ca3
movl $0x1, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/mishun[P]plantri/plantri.c
// Function: has_min5_b
static int
has_min5_b(void)

/* Test if the graph has a B-reduction */ 

{
    EDGE *e,*elast;
    int i;

    for (i = 0; i < nv; ++i)
    if (degree[i] == 5)
    {
        e = elast = firstedge[i];
        do  
        {
            if (e == e->min && degree[e->end] == 5
                    && degree[e->prev->end] == 5
                    && degree[e->next->end] == 5
		    && (is_valid_min5_b(e,FALSE) || is_valid_min5_b(e,TRUE)))
                return TRUE;
            e = e->next;
        } while (e != elast);
    }

    return FALSE;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
movl 0x23034f(%rip), %eax    # 0x244610
testl %eax, %eax
jle 0x14355
xorl %r14d, %r14d
leaq 0x1391d(%rip), %r15     # 0x27bf0
leaq 0x13716(%rip), %r12     # 0x279f0
movl $0x1, %ebp
cmpl $0x5, (%r15,%r14,4)
jne 0x1434a
movq (%r12,%r14,8), %r13
movq %r13, %rbx
cmpq 0x28(%rbx), %rbx
jne 0x1433b
movslq 0x4(%rbx), %rax
cmpl $0x5, (%r15,%rax,4)
jne 0x1433b
movq 0x10(%rbx), %rax
movslq 0x4(%rax), %rax
cmpl $0x5, (%r15,%rax,4)
jne 0x1433b
movq 0x18(%rbx), %rax
movslq 0x4(%rax), %rax
cmpl $0x5, (%r15,%rax,4)
jne 0x1433b
movq %rbx, %rdi
xorl %esi, %esi
callq 0x186e9
testl %eax, %eax
jne 0x14359
movq %rbx, %rdi
movl $0x1, %esi
callq 0x186e9
testl %eax, %eax
jne 0x1435e
movq 0x18(%rbx), %rbx
cmpq %r13, %rbx
jne 0x142ed
movl 0x2302c6(%rip), %eax    # 0x244610
incq %r14
movslq %eax, %rcx
cmpq %rcx, %r14
jl 0x142df
xorl %ebp, %ebp
jmp 0x1435e
movl $0x1, %ebp
movl %ebp, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mishun[P]plantri/plantri.c
// Function: is_min5_c_centre
static int
is_min5_c_centre(int v)
 
/* checks whether the configuration centered at vertex v is reducible by
   the c-reduction of the min5 generation.

   It assumes that there is no nf-4-cycle in the graph. It can be
   shown that it is enough to check the valencies of the center and its
   neighbours to be 5 and the second neighbours to be at least 6. In this
   case a 4-cut introduced by the reduction would imply that there was one
   before.
 
*/
 
{
 
  EDGE *run;
 
  if (degree[v]!=5) return FALSE;
 
  run=firstedge[v]; if(degree[run->end]!=5) return FALSE;
  run=run->next; if(degree[run->end]!=5) return FALSE;
  run=run->next; if(degree[run->end]!=5) return FALSE;
  run=run->next; if(degree[run->end]!=5) return FALSE;
  run=run->next; if(degree[run->end]!=5) return FALSE;
 
  run=run->invers->prev->prev->invers->next; /* edge 1*/
  if ((degree[run->start]<6) || (degree[run->end]<6)) return FALSE;
  run=run->invers->next->next->next; /* edge 2*/
  if (degree[run->end]<6) return FALSE;
  run=run->invers->next->next->next; /* edge 3*/
  if (degree[run->end]<6) return FALSE;
  run=run->invers->next->next->next; /* edge 4*/
  if (degree[run->end]<6) return FALSE;
 
  return TRUE;
}

// Assembly:
movslq %edi, %rdx
leaq 0x13877(%rip), %rcx     # 0x27bf0
xorl %eax, %eax
cmpl $0x5, (%rcx,%rdx,4)
jne 0x1445a
leaq 0x13664(%rip), %rsi     # 0x279f0
movq (%rsi,%rdx,8), %rdx
movslq 0x4(%rdx), %rsi
cmpl $0x5, (%rcx,%rsi,4)
jne 0x1445a
movq 0x18(%rdx), %rdx
movslq 0x4(%rdx), %rsi
cmpl $0x5, (%rcx,%rsi,4)
jne 0x1445a
movq 0x18(%rdx), %rdx
movslq 0x4(%rdx), %rsi
cmpl $0x5, (%rcx,%rsi,4)
jne 0x1445a
movq 0x18(%rdx), %rdx
movslq 0x4(%rdx), %rsi
cmpl $0x5, (%rcx,%rsi,4)
jne 0x1445a
movq 0x18(%rdx), %rdx
movslq 0x4(%rdx), %rsi
cmpl $0x5, (%rcx,%rsi,4)
jne 0x1445a
movq 0x20(%rdx), %rdx
movq 0x10(%rdx), %rdx
movq 0x10(%rdx), %rdx
movq 0x20(%rdx), %rdx
movq 0x18(%rdx), %rdx
movslq (%rdx), %rsi
cmpl $0x6, (%rcx,%rsi,4)
jl 0x1445a
movslq 0x4(%rdx), %rsi
cmpl $0x6, (%rcx,%rsi,4)
jl 0x1445a
movq 0x20(%rdx), %rdx
movq 0x18(%rdx), %rdx
movq 0x18(%rdx), %rdx
movq 0x18(%rdx), %rdx
movslq 0x4(%rdx), %rsi
cmpl $0x6, (%rcx,%rsi,4)
jl 0x1445a
movq 0x20(%rdx), %rdx
movq 0x18(%rdx), %rdx
movq 0x18(%rdx), %rdx
movq 0x18(%rdx), %rdx
movslq 0x4(%rdx), %rsi
cmpl $0x6, (%rcx,%rsi,4)
jl 0x1445a
movq 0x20(%rdx), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rax
movslq 0x4(%rax), %rdx
xorl %eax, %eax
cmpl $0x6, (%rcx,%rdx,4)
setge %al
retq
// File: /workspace/github_c_makefile_star2_O3/mishun[P]plantri/plantri.c
// Function: reduce_min5_c
static void
reduce_min5_c(EDGE *e, EDGE *anchor)
{

  /* Like other reduction operations, this is not the reverse operation,
     but it relies on the map being EXACTLY the same as after the application 
     of the corresponding extend operation */

  EDGE *e1, *e2, *e3, *e4, *e5, *e1i, *e2i, *e3i, *e4i, *e5i;
  int v1, v2, v3, v4, v5, origin;

  e1=e->invers->prev->prev->invers->next;
  e1i=e1->invers;
  e2=e1i->next->next->next;
  e2i=e2->invers;
  e3=e2i->next->next->next;
  e3i=e3->invers;
  e4=e3i->next->next->next;
  e4i=e4->invers;
  e5=e4i->next->next->next;
  e5i=e5->invers;

  v1=e1->start;
  v2=e1->end;
  v3=e3->start;
  v4=e3->end;
  v5=e5->start;
  origin=anchor->start;

  firstedge[v1]=e1;
  degree[v1]--;
  firstedge[v2]=e2;
  degree[v2]--;
  firstedge[v3]=e3;
  degree[v3]--;
  firstedge[v4]=e4;
  degree[v4]--;
  firstedge[v5]=e5;
  degree[v5]--;
  firstedge[origin]=anchor;

  nv-=5; ne-=30;

  e1->prev=e5i->next=anchor->invers;
  anchor=anchor->prev;
  e2->prev=e1i->next=anchor->invers;
  anchor=anchor->prev;
  e3->prev=e2i->next=anchor->invers;
  anchor=anchor->prev;
  e4->prev=e3i->next=anchor->invers;
  anchor=anchor->prev;
  e5->prev=e4i->next=anchor->invers;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq 0x20(%rdi), %r14
movq 0x18(%r14), %rcx
movq 0x18(%rcx), %rcx
movq 0x18(%rcx), %r9
movq 0x20(%r9), %rax
movq %rax, -0x8(%rsp)
movq 0x18(%rax), %rdx
movq 0x18(%rdx), %rdx
movq 0x18(%rdx), %r10
movq 0x20(%r10), %rax
movq %rax, -0x10(%rsp)
movq 0x18(%rax), %r8
movq 0x18(%r8), %r8
movq 0x18(%r8), %r11
movq 0x20(%r11), %rax
movq %rax, -0x18(%rsp)
movq 0x18(%rax), %rbx
movq 0x18(%rbx), %rbx
movq 0x18(%rbx), %rbx
movq 0x20(%rbx), %rax
movq %rax, -0x20(%rsp)
movslq (%rdi), %r15
movslq 0x4(%rdi), %r12
movslq (%r10), %r13
movslq 0x4(%r10), %rbp
movslq (%rbx), %rdx
movslq (%rsi), %r8
leaq 0x13718(%rip), %rcx     # 0x27bf0
decl (%rcx,%r15,4)
decl (%rcx,%r12,4)
leaq 0x13509(%rip), %rax     # 0x279f0
movq %rdi, (%rax,%r15,8)
decl (%rcx,%r13,4)
movq %r9, (%rax,%r12,8)
decl (%rcx,%rbp,4)
movq %r10, (%rax,%r13,8)
decl (%rcx,%rdx,4)
movq %r11, (%rax,%rbp,8)
addl $-0x5, 0x230108(%rip)   # 0x244610
movq %rbx, (%rax,%rdx,8)
addl $-0x1e, 0x230101(%rip)  # 0x244614
movq %rsi, (%rax,%r8,8)
movq 0x20(%rsi), %rax
movq -0x20(%rsp), %rcx
movq %rax, 0x18(%rcx)
movq %rax, 0x10(%rdi)
movq 0x10(%rsi), %rax
movq 0x20(%rax), %rcx
movq %rcx, 0x18(%r14)
movq %rcx, 0x10(%r9)
movq 0x10(%rax), %rax
movq 0x20(%rax), %rcx
movq -0x8(%rsp), %rdx
movq %rcx, 0x18(%rdx)
movq %rcx, 0x10(%r10)
movq 0x10(%rax), %rax
movq 0x20(%rax), %rcx
movq -0x10(%rsp), %rdx
movq %rcx, 0x18(%rdx)
movq %rcx, 0x10(%r11)
movq 0x10(%rax), %rax
movq 0x20(%rax), %rax
movq -0x18(%rsp), %rcx
movq %rax, 0x18(%rcx)
movq %rax, 0x10(%rbx)
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mishun[P]plantri/plantri.c
// Function: prune_poly_edgelist
static void
prune_poly_edgelist(EDGE *old[], int numold, EDGE *newe[], int *numnew)

/* Copy from old[0..numold-1] to newe[0..*numnew-1] each edge e with
   these two properties:
   1. Both ends of e have degree >= minpolydeg+1.
   2. e is contained in a 3-face.
   It is legal that old and newe and &numold and numnew are the same.

   17Aug2005: Changed "new" to "newe" to avoid Codewarrior bug.
*/

{
    int i,counter=0;
    EDGE *e;

    for (i=0; i<numold; i++, old++)
      { e = *old; 
        if (degree[e->start] > minpolydeg && degree[e->end] > minpolydeg
	     && (e->left_facesize == 3 || e->invers->left_facesize == 3))
            newe[counter++]=e;
      }

    *numnew=counter;
}

// Assembly:
testl %esi, %esi
jle 0x145d9
pushq %rbx
movl 0x11c13(%rip), %eax     # 0x261a0
movl %esi, %esi
xorl %r9d, %r9d
leaq 0x13657(%rip), %r10     # 0x27bf0
xorl %r8d, %r8d
movq (%rdi,%r9,8), %r11
movslq (%r11), %rbx
cmpl %eax, (%r10,%rbx,4)
jle 0x145ce
movslq 0x4(%r11), %rbx
cmpl %eax, (%r10,%rbx,4)
jle 0x145ce
cmpl $0x3, 0x38(%r11)
je 0x145c4
movq 0x20(%r11), %rbx
cmpl $0x3, 0x38(%rbx)
jne 0x145ce
movslq %r8d, %rbx
incl %r8d
movq %r11, (%rdx,%rbx,8)
incq %r9
cmpl %r9d, %esi
jne 0x1459c
popq %rbx
jmp 0x145dc
xorl %r8d, %r8d
movl %r8d, (%rcx)
retq
// File: /workspace/github_c_makefile_star2_O3/mishun[P]plantri/plantri.c
// Function: threeconn
static int
threeconn(EDGE *e)

/* tests whether the graph obtained by deleting EDGE e is still 3-connected.
   The edge e may have been deleted or not, but the values in e must be
   as before it was (possibly) deleted. The map must have been 3-connected
   before -- so especially there weren't any vertices of degree 2.
   degree[] is not assumed correct for the endvertices of e.

   On the left hand side of e there must be a triangle
   (e->left_facesize==3) and it is assumed that it is checked before
   that the endvertices of e have degree at least 3 after the deletion.

   If there is a 2-cut, e->start and e->end cannot be contained, but they
   must be in different components, so v=e->prev->end MUST be contained.
   It is checked whether v is contained in a face that shares yet another
   vertex with the face formerly on the right hand side of e (the new face
   obtained by deleting e).

   Returns 1 if it is 3-connected after deleting e, 0 else.  */

{
    EDGE *run, *start, *end;

    start=e->prev->invers;
    if (degree[start->start]==3) return 1;

    RESETMARKS_V;

    /* The endvertices of e need not be marked */
    for ( run=e->next, end=e->invers->prev->invers ;
          run != end; run=run->invers->next) MARK_V(run->end);

    
    end=start->prev->prev; /* stops the running around the vertex before
			      the last face */

/* The first face and the last face contain also one of the endvertices of e,
   so if they also contain marked vertices, then there already was a 2-cut. */

    start=start->next;

    while (start != end)
      { run=start->invers;
        start=start->next;
        for ( ; run != start; run=run->prev->invers)
	    if (ISMARKED_V(run->start)) return 0; 
      }

    return 1;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movq 0x10(%rdi), %rax
movq 0x20(%rax), %r15
movslq (%r15), %rax
leaq 0x117f2(%rip), %rcx     # 0x27bf0
movl $0x1, %ebx
cmpl $0x3, (%rcx,%rax,4)
je 0x164ba
movq %rdi, %r14
movl 0xfc7a(%rip), %ecx      # 0x26090
leal 0x1(%rcx), %eax
movl %eax, 0xfc71(%rip)      # 0x26090
cmpl $0x7530, %ecx           # imm = 0x7530
jl 0x16449
movl $0x1, 0xfc5f(%rip)      # 0x26090
leaq 0x2747f8(%rip), %rdi    # 0x28ac30
movl $0x100, %edx            # imm = 0x100
xorl %esi, %esi
callq 0x1030
movl $0x1, %eax
movq 0x18(%r14), %rcx
movq 0x20(%r14), %rdx
movq 0x10(%rdx), %rdx
movq 0x20(%rdx), %rdx
cmpq %rdx, %rcx
je 0x16479
leaq 0x2747cb(%rip), %rsi    # 0x28ac30
movslq 0x4(%rcx), %rdi
movl %eax, (%rsi,%rdi,4)
movq 0x20(%rcx), %rcx
movq 0x18(%rcx), %rcx
cmpq %rdx, %rcx
jne 0x16465
movq 0x10(%r15), %rcx
movq 0x18(%r15), %rdx
movq 0x10(%rcx), %rcx
cmpq %rcx, %rdx
je 0x164ba
leaq 0x27479f(%rip), %rsi    # 0x28ac30
movq 0x20(%rdx), %rdi
movq 0x18(%rdx), %rdx
cmpq %rdx, %rdi
je 0x164b1
movslq (%rdi), %r8
cmpl %eax, (%rsi,%r8,4)
je 0x164b8
movq 0x10(%rdi), %rdi
movq 0x20(%rdi), %rdi
jmp 0x16499
cmpq %rcx, %rdx
jne 0x16491
jmp 0x164ba
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/mishun[P]plantri/plantri.c
// Function: switch_edge
static void
switch_edge(EDGE *e)

/* switches edge e -- that is: removes e and puts in the other diagonal in 
   the 4-gon given by the two triangles adjacent to e */
{ 
    register EDGE *work1, *work2;


/* closing the gap when e is removed */
    firstedge[e->start]=e->next;
    e->prev->next=e->next;
    e->next->prev=e->prev;
    (degree[e->start])--;

/* rotating e */
    work1=e->next->invers; work2=work1->next;
    e->start=work1->start; e->end=e->prev->end;
    e->prev=work1; e->next=work2;
    work1->next=e; work2->prev=e;
    (degree[work1->start])++;

/* Now doing the same with e->invers */

    e=e->invers;
    firstedge[e->start]=e->next;
    e->prev->next=e->next;
    e->next->prev=e->prev;
    (degree[e->start])--;
    work1=e->next->invers; work2=work1->next;
    e->start=work1->start; e->end=e->prev->end;
    e->prev=work1; e->next=work2;
    work1->next=e; work2->prev=e;
    (degree[work1->start])++;
}

// Assembly:
movq 0x18(%rdi), %rax
movslq (%rdi), %rcx
leaq 0x10e9e(%rip), %rdx     # 0x279f0
movq %rax, (%rdx,%rcx,8)
movq 0x10(%rdi), %rsi
movq %rax, 0x18(%rsi)
movq 0x18(%rdi), %r8
movq %rsi, 0x10(%r8)
leaq 0x11083(%rip), %rax     # 0x27bf0
decl (%rax,%rcx,4)
movq 0x20(%r8), %rcx
movq 0x18(%rcx), %r8
movslq (%rcx), %r9
movl %r9d, (%rdi)
movl 0x4(%rsi), %esi
movl %esi, 0x4(%rdi)
movq %rcx, 0x10(%rdi)
movq %r8, 0x18(%rdi)
movq %rdi, 0x18(%rcx)
movq %rdi, 0x10(%r8)
incl (%rax,%r9,4)
movq 0x20(%rdi), %rcx
movq 0x18(%rcx), %rsi
movslq (%rcx), %rdi
movq %rsi, (%rdx,%rdi,8)
movq 0x10(%rcx), %rdx
movq %rsi, 0x18(%rdx)
movq 0x18(%rcx), %rsi
movq %rdx, 0x10(%rsi)
decl (%rax,%rdi,4)
movq 0x20(%rsi), %rsi
movq 0x18(%rsi), %rdi
movslq (%rsi), %r8
movl %r8d, (%rcx)
movl 0x4(%rdx), %edx
movl %edx, 0x4(%rcx)
movq %rsi, 0x10(%rcx)
movq %rdi, 0x18(%rcx)
movq %rcx, 0x18(%rsi)
movq %rcx, 0x10(%rdi)
incl (%rax,%r8,4)
retq
// File: /workspace/github_c_makefile_star2_O3/mishun[P]plantri/plantri.c
// Function: prune_edgelist
static void
prune_edgelist(EDGE *edge[], int *nedges, int nbtot)

/* Reduce edge[0..*nedges-1] (as undirected edges) according to the group */

{
    int i,oldnum,newnum;
    EDGE **nb0,**nb,**nblim;
 
    if (nbtot == 1) return;
        
    nb0 = (EDGE**)numbering[0];
    nblim = (EDGE**)numbering[nbtot];
    for (i = 0; i < ne; ++i) nb0[i]->index = i;
 
    RESETMARKS;
   
    oldnum = *nedges; 
    newnum = 0;
    for (i = 0; i < oldnum; ++i)
    {
        nb = nb0 + edge[i]->index;
        if (!ISMARKEDLO(*nb))
        {
	    edge[newnum++] = edge[i];
            for ( ; nb < nblim; nb += MAXE) MARKLO((*nb)->min);
        }
    }
    *nedges = newnum;
}

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
leaq 0x10673(%rip), %rax     # 0x27cf0
movslq 0x22cf90(%rip), %rcx    # 0x244614
testq %rcx, %rcx
jle 0x176a2
xorl %r8d, %r8d
movq %rax, %r9
movq (%r9), %r10
movl %r8d, 0x34(%r10)
incq %r8
addq $0x8, %r9
cmpq %r8, %rcx
jne 0x1768f
movl 0xe9e3(%rip), %r8d      # 0x2608c
leal 0x2(%r8), %ecx
movl %ecx, 0xe9d9(%rip)      # 0x2608c
cmpl $0x752f, %r8d           # imm = 0x752F
jl 0x176ec
movl $0x2, 0xe9c6(%rip)      # 0x2608c
movl $0x30, %ecx
leaq 0x22cf4e(%rip), %r8     # 0x244620
movl $0x0, (%rcx,%r8)
addq $0x40, %rcx
cmpq $0x46630, %rcx          # imm = 0x46630
jne 0x176d2
movl $0x2, %ecx
movslq (%rsi), %r8
testq %r8, %r8
jle 0x17755
movl %edx, %edx
imulq $0xba0, %rdx, %rdx      # imm = 0xBA0
leaq (%rax,%rdx), %r10
xorl %r11d, %r11d
xorl %r9d, %r9d
movq (%rdi,%r11,8), %r14
movslq 0x34(%r14), %rbx
movq (%rax,%rbx,8), %r15
cmpl %ecx, 0x30(%r15)
je 0x1774b
leaq (,%rbx,8), %r15
movslq %r9d, %r12
incl %r9d
movq %r14, (%rdi,%r12,8)
cmpq %rdx, %r15
jge 0x1774b
leaq (%rax,%rbx,8), %rbx
movq (%rbx), %r14
movq 0x28(%r14), %r14
movl %ecx, 0x30(%r14)
addq $0xba0, %rbx            # imm = 0xBA0
cmpq %r10, %rbx
jb 0x17734
incq %r11
cmpq %r8, %r11
jne 0x17707
jmp 0x17758
xorl %r9d, %r9d
movl %r9d, (%rsi)
popq %rbx
popq %r12
popq %r14
popq %r15
retq