LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x75cb
movl $0x1, 0x23d05b(%rip)    # 0x244610
movl $0x0, 0x23d055(%rip)    # 0x244614
movq $0x0, 0x20426(%rip) # 0x279f0
retq
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
leaq 0x23d047(%rip), %rcx    # 0x244620
movq %rcx, 0x20410(%rip)     # 0x279f0
leal -0x1(%rdi), %eax
movl %eax, 0x20607(%rip)     # 0x27bf0
movslq %edi, %r8
shlq $0x6, %r8
leaq (%rcx,%r8), %rdx
cmpl $0x2, %edi
jl 0x7680
movl %edi, %esi
leaq -0x8(,%rsi,8), %rsi
addq %rcx, %r8
addq $-0x3c, %r8
movl $0x1, %r9d
xorl %r10d, %r10d
leaq 0x205d2(%rip), %r11     # 0x27bf0
leaq 0x203cb(%rip), %rbx     # 0x279f0
xorl %r14d, %r14d
movq %rcx, %r15
leaq (%r8,%r14,8), %r12
addq $-0x4, %r12
movl %r10d, 0x4(%r12)
movl %r10d, (%rcx,%r14,8)
movl %r9d, (%r12)
movl %r9d, 0x4(%rcx,%r14,8)
movq %r12, 0x20(%rcx,%r14,8)
movq %r15, 0x20(%r12)
movq %r15, 0x28(%r12)
movq %r15, 0x28(%rcx,%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 0x762b
cmpl $0x3, %edi
leaq 0x23cfd6(%rip), %rsi    # 0x244660
movq %rcx, %r8
cmovgeq %rsi, %r8
movq %r8, 0x23cfa0(%rip)     # 0x244638
addq $-0x80, %rdx
movq %rdx, 0x23cf8d(%rip)    # 0x244630
cmpl $0x4, %edi
jl 0x76c9
leal -0x3(%rdi), %edx
leaq 0x23cfae(%rip), %r8     # 0x244660
leaq -0x40(%r8), %rsi
movq %rsi, 0x10(%r8)
leaq 0x40(%r8), %rsi
movq %rsi, 0x18(%r8)
movq %rsi, %r8
decl %edx
jne 0x76b2
cmpl $0x3, %edi
jl 0x76da
leaq -0x40(%rsi), %rdx
movq %rdx, 0x10(%rsi)
movq %rcx, 0x18(%rsi)
movl %edi, 0x23cf30(%rip)    # 0x244610
addl %eax, %eax
movl %eax, 0x23cf2c(%rip)    # 0x244614
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x2396e3(%rip), %eax    # 0x244610
movl 0x2396e1(%rip), %ecx    # 0x244614
leal 0x1(%rax,%rcx), %eax
movslq %eax, %r14
movq %rsp, %r15
movq %r15, %rdi
callq 0xb02d
movl $0x1, %esi
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x10f0
cmpq %r14, %rax
jne 0xaf92
testl %ebp, %ebp
je 0xaf84
movq %rsp, %r15
movq %r15, %rdi
callq 0xb172
movl $0x1, %esi
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x10f0
cmpq %r14, %rax
jne 0xaf97
addq $0x1b8, %rsp            # imm = 0x1B8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x26fa
callq 0x272e
// File: /workspace/github_c_makefile_star2_O1/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 0x239660(%rip), %eax    # 0x244614
movl %eax, %ecx
shrl $0x1f, %ecx
addl %eax, %ecx
sarl %ecx
addl %eax, %ecx
subl 0x23964b(%rip), %ecx    # 0x244610
addl $0x3, %ecx
movslq %ecx, %r14
movq %rsp, %r15
movq %r15, %rdi
callq 0xb2bb
movl $0x1, %esi
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x10f0
cmpq %r14, %rax
jne 0xb023
testl %ebp, %ebp
je 0xb015
movq %rsp, %r15
movq %r15, %rdi
callq 0xb469
movl $0x1, %esi
movq %r15, %rdi
movq %r14, %rdx
movq %rbx, %rcx
callq 0x10f0
cmpq %r14, %rax
jne 0xb028
addq $0x1f8, %rsp            # imm = 0x1F8
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x2762
callq 0x2796
// File: /workspace/github_c_makefile_star2_O1/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
movq %rdx, 0x8(%rsp)
movl %esi, (%rsp)
movl %edi, %r14d
movslq 0x2380c0(%rip), %r15    # 0x244610
leaq 0x27e7e9(%rip), %rbp    # 0x28ad40
testq %r15, %r15
jle 0xc588
movq %r15, %r13
shlq $0x6, %r13
xorl %ebx, %ebx
movq %rbp, %r12
leaq (%rbx,%rbp), %rdi
xorl %esi, %esi
movq %r15, %rdx
callq 0x1030
movb $0x1, (%r12)
addq $0x41, %r12
addq $0x40, %rbx
cmpq %rbx, %r13
jne 0xc568
movl $0x0, 0x4(%rsp)
testl %r15d, %r15d
jle 0xc605
movl 0x19c05(%rip), %eax     # 0x261a0
xorl %ecx, %ecx
leaq 0x1b44c(%rip), %rdx     # 0x279f0
leaq 0x1b645(%rip), %rdi     # 0x27bf0
xorl %esi, %esi
movq (%rdx,%rcx,8), %r8
movq %r8, %r9
cmpq 0x28(%r9), %r9
jne 0xc5d7
movslq (%r9), %r10
cmpl %eax, (%rdi,%r10,4)
jle 0xc5d7
movslq 0x4(%r9), %r10
cmpl %eax, (%rdi,%r10,4)
jle 0xc5d7
movslq %esi, %r10
incl %esi
movq %r9, 0x10(%rsp,%r10,8)
movl $0x4, 0x38(%r9)
movslq (%r9), %r10
movslq 0x4(%r9), %r11
shlq $0x6, %r10
addq %rbp, %r10
movb $0x1, (%r11,%r10)
movq 0x18(%r9), %r9
cmpq %r8, %r9
jne 0xc5b4
incq %rcx
cmpq %r15, %rcx
jne 0xc5ad
jmp 0xc607
xorl %esi, %esi
leaq 0x4(%rsp), %r15
movl %esi, (%r15)
leaq 0x10(%rsp), %r12
movq %r12, %rdi
movq %r12, %rdx
movq %r15, %rcx
callq 0xcbfc
movl (%r15), %ecx
movl %r14d, %edi
movl (%rsp), %esi
movq %r12, %rdx
movl $0x4, %r8d
xorl %r9d, %r9d
pushq 0x8(%rsp)
pushq $0x0
callq 0xcc5a
addq $0x5f8, %rsp            # imm = 0x5F8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/mishun[P]plantri/plantri.c
// Function: extend_quadr_P1
static EDGE
*extend_quadr_P1(EDGE *e)

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

   It returns the directed edge characterizing this operation.
*/

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

  center=e->start; 
  end=e->end;
  e1=e->prev;
  e1i=e1->invers;
  e2=e1i->prev;
  end1=e2->start;

  e3=e->next;
  e3i=e3->invers;
  e4=e3i->next;
  end2=e4->start;

  e1->next=e3; e3->prev=e1; degree[center]--; firstedge[center]=e1;

  start=quadr_P1(nv);
  dummy=start+1;
  start->start=dummy->end=end1;
  degree[end1]++;
  start->next=e1i; e1i->prev=start;
  start->prev=e2; e2->next=start;

  dummy->next=e; e->prev=dummy;

  start+=2; dummy=start+1;
  start->start=dummy->end=end2;
  degree[end2]++;
  e3i->next=start; start->prev=e3i;
  e4->prev=start; start->next=e4;

  e->next=dummy; dummy->prev=e;

  degree[nv]=3; e->start=e->invers->end=nv; firstedge[nv]=e;
  nv++; ne+=4;

  return (e); 
}

// Assembly:
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movq %rdi, %rax
movslq (%rdi), %rsi
movq 0x10(%rdi), %r9
movq 0x18(%rdi), %rdx
movq 0x20(%r9), %r10
movq 0x10(%r10), %r11
movslq (%r11), %rbx
movq 0x20(%rdx), %rdi
movq 0x18(%rdi), %rcx
movslq (%rcx), %r14
movq %rdx, 0x18(%r9)
movq %r9, 0x10(%rdx)
leaq 0x1b147(%rip), %r8      # 0x27bf0
decl (%r8,%rsi,4)
leaq 0x1af3c(%rip), %rdx     # 0x279f0
movq %r9, (%rdx,%rsi,8)
movslq 0x237b51(%rip), %rsi    # 0x244610
movq %rsi, %r9
shlq $0x8, %r9
leaq 0x237b53(%rip), %r15    # 0x244620
leaq (%r9,%r15), %r12
addq $0x100, %r12            # imm = 0x100
leaq (%r9,%r15), %r13
addq $0x140, %r13            # imm = 0x140
incl (%r8,%rbx,4)
movl %ebx, 0x4(%r13)
movl %ebx, -0x40(%r13)
movq %r10, -0x28(%r13)
movq %r12, 0x10(%r10)
movq %r11, -0x30(%r13)
movq %r12, 0x18(%r11)
movq %rax, 0x18(%r13)
movq %r13, 0x10(%rax)
leaq 0x180(%r9,%r15), %r10
addq %r15, %r9
addq $0x1c0, %r9             # imm = 0x1C0
movl %r14d, 0x4(%r9)
movl %r14d, -0x40(%r9)
incl (%r8,%r14,4)
movq %r10, 0x18(%rdi)
movq %rdi, -0x30(%r9)
movq %r10, 0x10(%rcx)
movq %rcx, -0x28(%r9)
movq %r9, 0x18(%rax)
movq %rax, 0x10(%r9)
movl $0x3, (%r8,%rsi,4)
movq 0x20(%rax), %rcx
movl %esi, 0x4(%rcx)
movl %esi, (%rax)
movq %rax, (%rdx,%rsi,8)
leal 0x1(%rsi), %ecx
movl %ecx, 0x237ab5(%rip)    # 0x244610
addl $0x4, 0x237ab2(%rip)    # 0x244614
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x237a9b(%rip)          # 0x244610
addl $-0x4, 0x237a98(%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 0x1b034(%rip), %rdx     # 0x27bf0
decl (%rdx,%rcx,4)
leaq 0x1ae2a(%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_O1/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 0xcc53
pushq %rbx
movl 0x19599(%rip), %eax     # 0x261a0
movl %esi, %esi
xorl %r9d, %r9d
leaq 0x1afdd(%rip), %r10     # 0x27bf0
xorl %r8d, %r8d
movq (%rdi,%r9,8), %r11
movslq (%r11), %rbx
cmpl %eax, (%r10,%rbx,4)
jle 0xcc48
movslq 0x4(%r11), %rbx
cmpl %eax, (%r10,%rbx,4)
jle 0xcc48
cmpl $0x4, 0x38(%r11)
je 0xcc3e
movq 0x20(%r11), %rbx
cmpl $0x4, 0x38(%rbx)
jne 0xcc48
movslq %r8d, %rbx
incl %r8d
movq %r11, (%rdx,%rbx,8)
incq %r9
cmpl %r9d, %esi
jne 0xcc16
popq %rbx
jmp 0xcc56
xorl %r8d, %r8d
movl %r8d, (%rcx)
retq
// File: /workspace/github_c_makefile_star2_O1/mishun[P]plantri/plantri.c
// Function: mark_edge_orbits
static void
mark_edge_orbits(EDGE *edge[], int count, int minimal[], int nbtot)

/* edge[0..count-1] is a list of edges.  Put minimal[i] = 1 if
   edge[i] is the first appearance of its orbit, and  minimal[i] = 0
   if not.  Orbits on undirected edges are considered. */
{
    int i;
    EDGE **nb0,**nb,**nblim;
 
    if (nbtot == 1) 
        for (i = 0; i < count; ++i) minimal[i] = 1;
    else
    {
        nb0 = (EDGE**)numbering[0];
        nblim = (EDGE**)numbering[nbtot];
        for (i = 0; i < ne; ++i) nb0[i]->index = i;
 
        RESETMARKS;
    
        for (i = 0; i < count; ++i)
        {
            nb = nb0 + edge[i]->index;
            if (!ISMARKEDLO((*nb)->min))
            {
                minimal[i] = 1;
                for ( ; nb < nblim; nb += MAXE) MARKLO((*nb)->min);
            }
            else
                minimal[i] = 0;
        }
    }
}

// Assembly:
cmpl $0x1, %ecx
jne 0xe216
testl %esi, %esi
jle 0xe215
movl %esi, %eax
xorl %ecx, %ecx
movl $0x1, (%rdx,%rcx,4)
incq %rcx
cmpq %rcx, %rax
jne 0xe206
retq
pushq %rbx
leaq 0x19ad2(%rip), %rax     # 0x27cf0
movslq 0x2363ef(%rip), %r8     # 0x244614
testq %r8, %r8
jle 0xe243
xorl %r9d, %r9d
movq %rax, %r10
movq (%r10), %r11
movl %r9d, 0x34(%r11)
incq %r9
addq $0x8, %r10
cmpq %r9, %r8
jne 0xe230
movl 0x17e4a(%rip), %r8d     # 0x26094
leal 0x2(%r8), %r9d
movl %r9d, 0x17e3f(%rip)     # 0x26094
cmpl $0x752f, %r8d           # imm = 0x752F
jl 0xe28a
movl $0x2, 0x17e2c(%rip)     # 0x26094
movl $0x30, %r8d
leaq 0x2363ab(%rip), %r9     # 0x244620
movl $0x0, (%r8,%r9)
addq $0x40, %r8
cmpq $0x46630, %r8           # imm = 0x46630
jne 0xe275
testl %esi, %esi
jle 0xe300
movslq %ecx, %rcx
imulq $0xba0, %rcx, %rcx      # imm = 0xBA0
leaq (%rax,%rcx), %r8
movl 0x17df1(%rip), %r9d     # 0x26094
movl %esi, %esi
xorl %r10d, %r10d
movq (%rdi,%r10,8), %r11
movslq 0x34(%r11), %r11
movq (%rax,%r11,8), %rbx
movq 0x28(%rbx), %rbx
cmpl %r9d, 0x30(%rbx)
jne 0xe2c8
movl $0x0, (%rdx,%r10,4)
jmp 0xe2f8
leaq (,%r11,8), %rbx
movl $0x1, (%rdx,%r10,4)
cmpq %rcx, %rbx
jge 0xe2f8
leaq (%rax,%r11,8), %r11
movq (%r11), %rbx
movq 0x28(%rbx), %rbx
movl %r9d, 0x30(%rbx)
addq $0xba0, %r11            # imm = 0xBA0
cmpq %r8, %r11
jb 0xe2e1
incq %r10
cmpq %rsi, %r10
jne 0xe2a8
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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, 0x23630b(%rip)    # 0x244614
movq 0x10(%rdi), %rax
movq %rdi, 0x18(%rax)
movq 0x18(%rdi), %rax
movq %rdi, 0x10(%rax)
movslq (%rdi), %rax
leaq 0x198cd(%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 0xe360
movl 0x38(%rax), %edx
movl %edx, 0x38(%rcx)
movq 0x10(%rcx), %rcx
movq 0x20(%rcx), %rcx
cmpq %rax, %rcx
jne 0xe350
movq 0x20(%rax), %rax
movq 0x10(%rax), %rcx
movq 0x20(%rcx), %rcx
cmpq %rax, %rcx
je 0xe384
movl 0x38(%rax), %edx
movl %edx, 0x38(%rcx)
movq 0x10(%rcx), %rcx
movq 0x20(%rcx), %rcx
cmpq %rax, %rcx
jne 0xe374
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x18(%rdi), %r11
movslq 0x4(%r11), %r10
movq 0x20(%r11), %rcx
movq 0x10(%rcx), %r8
movq 0x18(%rcx), %rbx
movq 0x20(%r8), %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 0x2360cb(%rip), %rdx    # 0x244610
movq %rdx, %rsi
shlq $0x9, %rsi
leaq 0x2360cd(%rip), %r14    # 0x244620
leaq (%rsi,%r14), %r15
addq $0x3140, %r15           # imm = 0x3140
movl %ebp, (%r15)
leaq 0x19688(%rip), %rdi     # 0x27bf0
incl (%rdi,%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 0x19458(%rip), %r13     # 0x279f0
movq %r12, (%r13,%r10,8)
movq %r12, 0x10(%rbx)
movq %r12, 0x18(%r8)
movq %rbx, 0x18(%r12)
movq %r8, 0x10(%r12)
leaq (%rsi,%r14), %r8
addq $0x3240, %r8            # imm = 0x3240
movl %eax, -0x3c(%r8)
movl %eax, (%r8)
incl (%rdi,%rax,4)
movq -0x8(%rsp), %rax
movq %r8, 0x10(%rax)
movq %r8, 0x18(%r9)
movq %rax, 0x18(%r8)
movq %r9, 0x10(%r8)
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(%rdi,%rdx,4)
movl %ecx, (%rdi,%rdx,4)
leaq 0x3180(%rsi,%r14), %rcx
movq %rax, (%r13,%rdx,8)
movq %rcx, 0x8(%r13,%rdx,8)
leal 0x2(%rdx), %ecx
movl %ecx, 0x235fea(%rip)    # 0x244610
addl $0x8, 0x235fe7(%rip)    # 0x244614
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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, 0x235fcc(%rip)   # 0x244610
addl $-0x8, 0x235fc9(%rip)   # 0x244614
movq 0x18(%rdi), %rax
movq 0x20(%rdi), %rcx
movslq (%rcx), %rdx
movq 0x10(%rcx), %rsi
movq 0x18(%rcx), %rcx
movq 0x20(%rcx), %rdi
movslq (%rdi), %r8
movq 0x18(%rdi), %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(%rax), %r14
movq %rcx, 0x18(%rsi)
movq %rsi, 0x10(%rcx)
leaq 0x19559(%rip), %rsi     # 0x27bf0
decl (%rsi,%rdx,4)
leaq 0x1934f(%rip), %r15     # 0x279f0
movq %rcx, (%r15,%rdx,8)
movq %rax, 0x10(%r9)
movq %rax, 0x18(%rdi)
movq %r9, 0x18(%rax)
movq %rdi, 0x10(%rax)
movl %r8d, 0x4(%r14)
movl %r8d, (%rax)
movq %rax, (%r15,%r8,8)
movq %rbx, 0x18(%r10)
movq %r10, 0x10(%rbx)
decl (%rsi,%r11,4)
movq %rbx, (%r15,%r11,8)
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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, 0x235de2(%rip)   # 0x244610
addl $-0x10, 0x235ddf(%rip)  # 0x244614
movq 0x18(%rdi), %rax
movq 0x18(%rax), %rax
movslq (%rdi), %rcx
leaq 0x193a9(%rip), %rdx     # 0x27bf0
decl (%rdx,%rcx,4)
leaq 0x1919f(%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_O1/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 0x19245(%rip), %r8      # 0x27bf0
xorl %eax, %eax
cmpl $0x3, (%r8,%rcx,4)
jne 0xea3b
movq 0x20(%rdi), %rcx
movq 0x10(%rcx), %rdx
movslq 0x4(%rdx), %r9
cmpl $0x3, (%r8,%r9,4)
jne 0xea3b
movq 0x10(%rdx), %rdx
movq 0x20(%rdx), %r9
movq 0x10(%r9), %r9
movslq 0x4(%r9), %r10
cmpl $0x3, (%r8,%r10,4)
jne 0xea3b
movq 0x10(%r9), %r10
movq 0x20(%r10), %r10
movq 0x10(%r10), %r10
movslq 0x4(%r10), %r11
cmpl $0x3, (%r8,%r11,4)
jne 0xea3b
movl (%r9), %r9d
movl (%r10), %r8d
movq 0x10(%rdi), %rdi
movq 0x18(%rsi), %rsi
movq 0x18(%rsi), %rsi
cmpq %rdi, %rsi
je 0xea20
movq 0x20(%rsi), %r10
movq 0x10(%r10), %r10
cmpl %r9d, 0x4(%r10)
jne 0xea07
jmp 0xea3b
movq 0x10(%rdx), %rdx
movq 0x18(%rcx), %rcx
cmpq %rdx, %rcx
je 0xea3c
movq 0x20(%rcx), %rsi
movq 0x10(%rsi), %rsi
cmpl %r8d, 0x4(%rsi)
jne 0xea24
retq
movl $0x1, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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, 0x23493e(%rip)    # 0x244610
jle 0xfd20
movq %rdi, %r14
xorl %r12d, %r12d
leaq 0x17d0f(%rip), %r13     # 0x279f0
xorl %ebp, %ebp
movq (%r13,%r12,8), %rbx
movq %rbx, %r15
cmpq 0x28(%r15), %r15
jne 0xfd06
movq %r15, %rdi
callq 0x122cc
testl %eax, %eax
je 0xfd06
movslq %ebp, %rax
incl %ebp
movq %r15, (%r14,%rax,8)
movq 0x18(%r15), %r15
cmpq %rbx, %r15
jne 0xfceb
incq %r12
movslq 0x2348f7(%rip), %rax    # 0x244610
cmpq %rax, %r12
jl 0xfce3
jmp 0xfd22
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_O1/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 %r15
pushq %r14
pushq %rbx
xorl %eax, %eax
leaq 0x157da(%rip), %rcx     # 0x279f0
leaq 0x159d3(%rip), %rdx     # 0x27bf0
leaq 0x2323fc(%rip), %rsi    # 0x244620
leaq 0x232535(%rip), %rdi    # 0x244760
movl $0x80, %r8d
xorl %r10d, %r10d
xorl %r9d, %r9d
leal 0x1(%r10), %ebp
testq %r9, %r9
leaq -0x40(%r9,%rsi), %r11
cmoveq %rdi, %r11
leaq (%rsi,%r9), %r14
leaq (%r14,%r8), %rbx
cmpq $0x100, %r9             # imm = 0x100
leaq 0x40(%r9,%rsi), %r15
movq %r15, -0x20(%r15)
movq %r14, 0x20(%r15)
movq %r14, 0x28(%r15)
movq %r14, -0x18(%r15)
movl %r10d, 0x4(%r15)
movl %r10d, -0x40(%r15)
movl %ebp, %r10d
cmovel %eax, %ebp
movl $0x2, (%rdx)
movq %r14, (%rcx)
movl %ebp, -0x3c(%r15)
movl %ebp, (%r15)
movq %r11, -0x28(%r15)
movq %r11, -0x30(%r15)
cmoveq %rsi, %rbx
movq %rbx, 0x18(%r15)
movq %rbx, 0x10(%r15)
addq %r8, %r9
addq $0x8, %rcx
addq $0x4, %rdx
cmpq $0x180, %r9             # imm = 0x180
jne 0x12237
movl $0x3, 0x232355(%rip)    # 0x244610
movl $0x6, 0x23234f(%rip)    # 0x244614
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x13dc2(%rip), %eax     # 0x26098
leal 0x1(%rax), %ecx
movl %ecx, 0x13db9(%rip)     # 0x26098
cmpl $0x7530, %eax           # imm = 0x7530
jl 0x12303
movl $0x1, 0x13da8(%rip)     # 0x26098
leaq 0x278939(%rip), %rdi    # 0x28ac30
movl $0x100, %edx            # imm = 0x100
xorl %esi, %esi
callq 0x1030
movq 0x10(%rbx), %rdx
movslq 0x4(%rdx), %rax
leaq 0x158de(%rip), %rcx     # 0x27bf0
movl (%rcx,%rax,4), %eax
cmpl $0x5, %eax
jl 0x12345
movq 0x20(%rdx), %rdx
movq 0x18(%rdx), %rdx
movl 0x13d70(%rip), %esi     # 0x26098
addl $-0x3, %eax
leaq 0x2788fe(%rip), %rdi    # 0x28ac30
movq 0x18(%rdx), %rdx
movslq 0x4(%rdx), %r8
movl %esi, (%rdi,%r8,4)
decl %eax
cmpl $0x1, %eax
jg 0x12332
movq 0x18(%rbx), %rsi
movslq 0x4(%rsi), %rax
movl (%rcx,%rax,4), %edx
xorl %eax, %eax
cmpl $0x5, %edx
jl 0x123b1
addl $-0x5, %edx
movq 0x20(%rsi), %rsi
movq 0x10(%rsi), %rsi
movl 0x13d30(%rip), %edi     # 0x26098
leaq 0x2788c1(%rip), %r8     # 0x28ac30
movq 0x10(%rsi), %rsi
movq 0x20(%rsi), %r9
movq 0x18(%r9), %r9
movslq 0x4(%rsi), %r10
movl (%rcx,%r10,4), %r10d
addl $-0x2, %r10d
decl %r10d
testl %r10d, %r10d
jle 0x1239f
movq 0x18(%r9), %r9
movslq 0x4(%r9), %r11
cmpl %edi, (%r8,%r11,4)
jne 0x12387
jmp 0x123ac
leal -0x1(%rdx), %r9d
testl %edx, %edx
movl %r9d, %edx
jg 0x1236f
jmp 0x123b1
movl $0x1, %eax
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x14211(%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 0x137fc
leaq 0x143d3(%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 0x230dc1(%rip)          # 0x244610
addl $-0x6, 0x230dbe(%rip)   # 0x244614
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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, 0x230a0a(%rip)    # 0x244610
jle 0x13c84
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
xorl %r14d, %r14d
leaq 0x13dd5(%rip), %r15     # 0x279f0
leaq 0x13fce(%rip), %r12     # 0x27bf0
movq (%r15,%r14,8), %r13
movq %r13, %rbx
cmpq 0x28(%rbx), %rbx
jne 0x13c59
movq 0x18(%rbx), %rax
movslq 0x4(%rax), %rax
cmpl $0x6, (%r12,%rax,4)
jl 0x13c59
movq 0x10(%rbx), %rax
movslq 0x4(%rax), %rax
cmpl $0x6, (%r12,%rax,4)
jl 0x13c59
movq %rbx, %rdi
callq 0x1841e
testl %eax, %eax
je 0x13c75
movq 0x18(%rbx), %rbx
cmpq %r13, %rbx
jne 0x13c29
incq %r14
movslq 0x2309a4(%rip), %rax    # 0x244610
cmpq %rax, %r14
jl 0x13c22
xorl %eax, %eax
jmp 0x13c7a
movl $0x1, %eax
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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
cmpl $0x0, 0x230338(%rip)    # 0x244610
jle 0x14368
xorl %r14d, %r14d
leaq 0x13908(%rip), %r15     # 0x27bf0
leaq 0x13701(%rip), %r12     # 0x279f0
movl $0x1, %ebp
cmpl $0x5, (%r15,%r14,4)
jne 0x14359
movq (%r12,%r14,8), %r13
movq %r13, %rbx
cmpq 0x28(%rbx), %rbx
jne 0x14350
movslq 0x4(%rbx), %rax
cmpl $0x5, (%r15,%rax,4)
jne 0x14350
movq 0x10(%rbx), %rax
movslq 0x4(%rax), %rax
cmpl $0x5, (%r15,%rax,4)
jne 0x14350
movq 0x18(%rbx), %rax
movslq 0x4(%rax), %rax
cmpl $0x5, (%r15,%rax,4)
jne 0x14350
movq %rbx, %rdi
xorl %esi, %esi
callq 0x18638
testl %eax, %eax
jne 0x1436c
movq %rbx, %rdi
movl $0x1, %esi
callq 0x18638
testl %eax, %eax
jne 0x14371
movq 0x18(%rbx), %rbx
cmpq %r13, %rbx
jne 0x14302
incq %r14
movslq 0x2302ad(%rip), %rax    # 0x244610
cmpq %rax, %r14
jl 0x142f4
xorl %ebp, %ebp
jmp 0x14371
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_O1/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 0x13864(%rip), %rcx     # 0x27bf0
xorl %eax, %eax
cmpl $0x5, (%rcx,%rdx,4)
jne 0x1446d
leaq 0x13651(%rip), %rsi     # 0x279f0
movq (%rsi,%rdx,8), %rdx
movslq 0x4(%rdx), %rsi
cmpl $0x5, (%rcx,%rsi,4)
jne 0x1446d
movq 0x18(%rdx), %rdx
movslq 0x4(%rdx), %rsi
cmpl $0x5, (%rcx,%rsi,4)
jne 0x1446d
movq 0x18(%rdx), %rdx
movslq 0x4(%rdx), %rsi
cmpl $0x5, (%rcx,%rsi,4)
jne 0x1446d
movq 0x18(%rdx), %rdx
movslq 0x4(%rdx), %rsi
cmpl $0x5, (%rcx,%rsi,4)
jne 0x1446d
movq 0x18(%rdx), %rdx
movslq 0x4(%rdx), %rsi
cmpl $0x5, (%rcx,%rsi,4)
jne 0x1446d
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 0x1446d
movslq 0x4(%rdx), %rsi
cmpl $0x6, (%rcx,%rsi,4)
jl 0x1446d
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 0x1446d
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 0x1446d
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_O1/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), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x20(%rax), %rax
movq 0x18(%rax), %r8
movq 0x20(%r8), %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), %rdi
movq 0x18(%rdi), %rdi
movq 0x18(%rdi), %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 (%r8), %r15
movslq 0x4(%r8), %r12
movslq (%r10), %r13
movslq 0x4(%r10), %rbp
movslq (%rbx), %rdx
movslq (%rsi), %rdi
leaq 0x136f1(%rip), %rcx     # 0x27bf0
decl (%rcx,%r15,4)
decl (%rcx,%r12,4)
leaq 0x134e2(%rip), %rax     # 0x279f0
movq %r8, (%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, 0x2300e1(%rip)   # 0x244610
movq %rbx, (%rax,%rdx,8)
addl $-0x1e, 0x2300da(%rip)  # 0x244614
movq %rsi, (%rax,%rdi,8)
movq 0x20(%rsi), %rax
movq -0x20(%rsp), %rcx
movq %rax, 0x18(%rcx)
movq %rax, 0x10(%r8)
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_O1/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 0x14600
pushq %rbx
movl 0x11bec(%rip), %eax     # 0x261a0
movl %esi, %esi
xorl %r9d, %r9d
leaq 0x13630(%rip), %r10     # 0x27bf0
xorl %r8d, %r8d
movq (%rdi,%r9,8), %r11
movslq (%r11), %rbx
cmpl %eax, (%r10,%rbx,4)
jle 0x145f5
movslq 0x4(%r11), %rbx
cmpl %eax, (%r10,%rbx,4)
jle 0x145f5
cmpl $0x3, 0x38(%r11)
je 0x145eb
movq 0x20(%r11), %rbx
cmpl $0x3, 0x38(%rbx)
jne 0x145f5
movslq %r8d, %rbx
incl %r8d
movq %r11, (%rdx,%rbx,8)
incq %r9
cmpl %r9d, %esi
jne 0x145c3
popq %rbx
jmp 0x14603
xorl %r8d, %r8d
movl %r8d, (%rcx)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x11930(%rip), %rcx     # 0x27bf0
movl $0x1, %ebx
cmpl $0x3, (%rcx,%rax,4)
je 0x16382
movq %rdi, %r14
movl 0xfdc0(%rip), %eax      # 0x26098
leal 0x1(%rax), %ecx
movl %ecx, 0xfdb7(%rip)      # 0x26098
cmpl $0x7530, %eax           # imm = 0x7530
jl 0x16305
movl $0x1, 0xfda6(%rip)      # 0x26098
leaq 0x274937(%rip), %rdi    # 0x28ac30
movl $0x100, %edx            # imm = 0x100
xorl %esi, %esi
callq 0x1030
movq 0x18(%r14), %rax
movq 0x20(%r14), %rcx
movq 0x10(%rcx), %rcx
movq 0x20(%rcx), %rcx
cmpq %rcx, %rax
je 0x1633b
movl 0xfd78(%rip), %edx      # 0x26098
leaq 0x274909(%rip), %rsi    # 0x28ac30
movslq 0x4(%rax), %rdi
movl %edx, (%rsi,%rdi,4)
movq 0x20(%rax), %rax
movq 0x18(%rax), %rax
cmpq %rcx, %rax
jne 0x16327
movq 0x10(%r15), %rax
movq 0x18(%r15), %rcx
movq 0x10(%rax), %rax
cmpq %rax, %rcx
je 0x16382
movl 0xfd46(%rip), %edx      # 0x26098
leaq 0x2748d7(%rip), %rsi    # 0x28ac30
movq 0x20(%rcx), %rdi
movq 0x18(%rcx), %rcx
cmpq %rcx, %rdi
je 0x16379
movslq (%rdi), %r8
cmpl %edx, (%rsi,%r8,4)
je 0x16380
movq 0x10(%rdi), %rdi
movq 0x20(%rdi), %rdi
jmp 0x16361
cmpq %rax, %rcx
jne 0x16359
jmp 0x16382
xorl %ebx, %ebx
movl %ebx, %eax
popq %rbx
popq %r14
popq %r15
retq