LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O2/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 0x2350db(%rip), %rdx    # 0x242600
movq %rdx, %rsi
shlq $0x9, %rsi
leaq 0x2350dd(%rip), %r14    # 0x242610
leaq (%rsi,%r14), %r15
addq $0x3140, %r15           # imm = 0x3140
movl %ebp, (%r15)
leaq 0x18698(%rip), %rdi     # 0x25be0
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 0x18468(%rip), %r13     # 0x259e0
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, 0x234ffa(%rip)    # 0x242600
addl $0x8, 0x234ff7(%rip)    # 0x242604
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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, 0x234fdc(%rip)   # 0x242600
addl $-0x8, 0x234fd9(%rip)   # 0x242604
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 0x18569(%rip), %rsi     # 0x25be0
decl (%rsi,%rdx,4)
leaq 0x1835f(%rip), %r15     # 0x259e0
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_O2/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, 0x234df2(%rip)   # 0x242600
addl $-0x10, 0x234def(%rip)  # 0x242604
movq 0x18(%rdi), %rax
movq 0x18(%rax), %rax
movslq (%rdi), %rcx
leaq 0x183b9(%rip), %rdx     # 0x25be0
decl (%rdx,%rcx,4)
leaq 0x181af(%rip), %rsi     # 0x259e0
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_O2/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), %r8
movslq 0x4(%r8), %rcx
leaq 0x18255(%rip), %rsi     # 0x25be0
xorl %eax, %eax
cmpl $0x3, (%rsi,%rcx,4)
jne 0xda1d
movq 0x20(%rdi), %rcx
movq 0x10(%rcx), %rdx
movslq 0x4(%rdx), %r9
cmpl $0x3, (%rsi,%r9,4)
jne 0xda1d
movq 0x10(%rdx), %rdx
movq 0x20(%rdx), %r9
movq 0x10(%r9), %r9
movslq 0x4(%r9), %r10
cmpl $0x3, (%rsi,%r10,4)
jne 0xda1d
movq 0x10(%r9), %r10
movq 0x20(%r10), %r10
movq 0x10(%r10), %r10
movslq 0x4(%r10), %r11
cmpl $0x3, (%rsi,%r11,4)
jne 0xda1d
movl (%r9), %r9d
movl (%r10), %esi
movq 0x10(%rdi), %rdi
movq 0x18(%r8), %r8
movq 0x18(%r8), %r8
cmpq %rdi, %r8
je 0xd9ff
movq 0x20(%r8), %r10
movq 0x10(%r10), %r10
cmpl %r9d, 0x4(%r10)
jne 0xd9e6
jmp 0xda1d
movq 0x10(%rdx), %rdi
pushq $0x1
popq %rdx
movq 0x18(%rcx), %rcx
cmpq %rdi, %rcx
je 0xda1e
movq 0x20(%rcx), %r8
movq 0x10(%r8), %r8
cmpl %esi, 0x4(%r8)
jne 0xda06
retq
movl %edx, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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)
movq %rdi, %r14
xorl %r12d, %r12d
leaq 0x16da3(%rip), %r13     # 0x259e0
xorl %ebp, %ebp
movslq 0x2339ba(%rip), %rax    # 0x242600
cmpq %rax, %r12
jge 0xec7c
movq (%r13,%r12,8), %rbx
movq %rbx, %r15
cmpq 0x28(%r15), %r15
jne 0xec6e
movq %r15, %rdi
callq 0x11124
testl %eax, %eax
je 0xec6e
movslq %ebp, %rax
incl %ebp
movq %r15, (%r14,%rax,8)
movq 0x18(%r15), %r15
cmpq %rbx, %r15
jne 0xec53
incq %r12
jmp 0xec3f
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_O2/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 %r14
pushq %rbx
leaq 0x14997(%rip), %rax     # 0x259e0
leaq 0x14b90(%rip), %rcx     # 0x25be0
xorl %edx, %edx
leaq 0x2315b7(%rip), %rsi    # 0x242610
leaq 0x2316f0(%rip), %rdi    # 0x242750
xorl %r10d, %r10d
xorl %r8d, %r8d
cmpq $0x180, %r8             # imm = 0x180
je 0x1110c
leal 0x1(%r10), %r9d
cmpq $0x100, %r8             # imm = 0x100
movl %r9d, %r11d
cmovel %edx, %r11d
movl $0x2, (%rcx)
leaq (%rsi,%r8), %rbx
movq %rbx, (%rax)
leaq 0x40(%r8,%rsi), %r14
movq %r14, -0x20(%r14)
movq %rbx, 0x20(%r14)
movq %rbx, 0x28(%r14)
movq %rbx, -0x18(%r14)
movl %r10d, 0x4(%r14)
movl %r10d, -0x40(%r14)
movl %r11d, -0x3c(%r14)
movl %r11d, (%r14)
testq %r8, %r8
je 0x110d9
leaq (%r8,%rsi), %r10
addq $-0x40, %r10
movq %r10, 0x58(%r10)
movq %r10, 0x50(%r10)
movq %rsi, %r10
cmpq $0x100, %r8             # imm = 0x100
jne 0x110e3
jmp 0x110ee
movq %rdi, 0x18(%r8,%rsi)
movq %rdi, 0x10(%r8,%rsi)
leaq (%r8,%rsi), %r10
addq $0x80, %r10
movq %r10, 0x58(%r8,%rsi)
movq %r10, 0x50(%r8,%rsi)
subq $-0x80, %r8
addq $0x8, %rax
addq $0x4, %rcx
movl %r9d, %r10d
jmp 0x11066
movl $0x3, 0x2314ea(%rip)    # 0x242600
movl $0x6, 0x2314e4(%rip)    # 0x242604
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movl 0x12f56(%rip), %eax     # 0x24080
leal 0x1(%rax), %ecx
movl %ecx, 0x12f4d(%rip)     # 0x24080
cmpl $0x7530, %eax           # imm = 0x7530
jl 0x11162
movl $0x1, 0x12f3c(%rip)     # 0x24080
xorl %eax, %eax
pushq $0x1
popq %rcx
leaq 0x277ad0(%rip), %rdx    # 0x288c20
cmpq $0x100, %rax            # imm = 0x100
je 0x11162
andl $0x0, (%rax,%rdx)
addq $0x4, %rax
jmp 0x11150
pushq $0x1
popq %rax
movq 0x10(%rdi), %rdx
movq 0x20(%rdx), %rsi
movq 0x18(%rsi), %r8
movslq 0x4(%rdx), %rsi
leaq 0x14a64(%rip), %rdx     # 0x25be0
movl (%rdx,%rsi,4), %r9d
addl $-0x4, %r9d
leaq 0x277a95(%rip), %rsi    # 0x288c20
testl %r9d, %r9d
jle 0x111a1
decl %r9d
movq 0x18(%r8), %r8
movslq 0x4(%r8), %r10
movl %ecx, (%rsi,%r10,4)
jmp 0x1118b
movq 0x18(%rdi), %r8
movq 0x20(%r8), %rdi
movq 0x10(%rdi), %rdi
movslq 0x4(%r8), %r8
movl (%rdx,%r8,4), %r8d
addl $-0x4, %r8d
testl %r8d, %r8d
jle 0x111f0
movq 0x10(%rdi), %rdi
decl %r8d
movq 0x20(%rdi), %r9
movq 0x18(%r9), %r9
movslq 0x4(%rdi), %r10
movl (%rdx,%r10,4), %r10d
addl $-0x2, %r10d
decl %r10d
testl %r10d, %r10d
jle 0x111b9
movq 0x18(%r9), %r9
movslq 0x4(%r9), %r11
cmpl %ecx, (%rsi,%r11,4)
jne 0x111d9
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x13501(%rip), %r15     # 0x259e0
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 0x124fc
leaq 0x136c3(%rip), %r12     # 0x25be0
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 0x2300b1(%rip)          # 0x242600
addl $-0x6, 0x2300ae(%rip)   # 0x242604
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
pushq %rax
xorl %ebx, %ebx
leaq 0x131f0(%rip), %r15     # 0x259e0
leaq 0x133e9(%rip), %r12     # 0x25be0
xorl %r13d, %r13d
movslq 0x22fdff(%rip), %rax    # 0x242600
cmpq %rax, %r13
jge 0x12850
movq (%r15,%r13,8), %rbp
movq %rbp, %r14
cmpq 0x28(%r14), %r14
jne 0x1283d
movq 0x18(%r14), %rax
movslq 0x4(%rax), %rax
cmpl $0x6, (%r12,%rax,4)
jl 0x1283d
movq 0x10(%r14), %rax
movslq 0x4(%rax), %rax
cmpl $0x6, (%r12,%rax,4)
jl 0x1283d
movq %r14, %rdi
callq 0x16e0b
testl %eax, %eax
je 0x1284b
movq 0x18(%r14), %r14
cmpq %rbp, %r14
jne 0x1280d
incq %r13
jmp 0x127fa
pushq $0x1
popq %rax
movl %eax, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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
leaq 0x12d87(%rip), %r15     # 0x25be0
leaq 0x12b80(%rip), %r12     # 0x259e0
pushq $0x1
popq %rbp
xorl %r13d, %r13d
movslq 0x22f793(%rip), %rax    # 0x242600
cmpq %rax, %r13
jge 0x12edd
cmpl $0x5, (%r15,%r13,4)
jne 0x12ed4
movq (%r12,%r13,8), %rbx
movq %rbx, %r14
cmpq 0x28(%r14), %r14
jne 0x12ecb
movslq 0x4(%r14), %rax
cmpl $0x5, (%r15,%rax,4)
jne 0x12ecb
movq 0x10(%r14), %rax
movslq 0x4(%rax), %rax
cmpl $0x5, (%r15,%rax,4)
jne 0x12ecb
movq 0x18(%r14), %rax
movslq 0x4(%rax), %rax
cmpl $0x5, (%r15,%rax,4)
jne 0x12ecb
movq %r14, %rdi
xorl %esi, %esi
callq 0x1700a
testl %eax, %eax
jne 0x12ed9
movq %r14, %rdi
movl %ebp, %esi
callq 0x1700a
testl %eax, %eax
jne 0x12ed9
movq 0x18(%r14), %r14
cmpq %rbx, %r14
jne 0x12e80
incq %r13
jmp 0x12e66
movl %ebp, %eax
jmp 0x12edf
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x12ce8(%rip), %rcx     # 0x25be0
xorl %eax, %eax
cmpl $0x5, (%rcx,%rdx,4)
jne 0x12fd9
leaq 0x12ad5(%rip), %rsi     # 0x259e0
movq (%rsi,%rdx,8), %rdx
movslq 0x4(%rdx), %rsi
cmpl $0x5, (%rcx,%rsi,4)
jne 0x12fd9
movq 0x18(%rdx), %rdx
movslq 0x4(%rdx), %rsi
cmpl $0x5, (%rcx,%rsi,4)
jne 0x12fd9
movq 0x18(%rdx), %rdx
movslq 0x4(%rdx), %rsi
cmpl $0x5, (%rcx,%rsi,4)
jne 0x12fd9
movq 0x18(%rdx), %rdx
movslq 0x4(%rdx), %rsi
cmpl $0x5, (%rcx,%rsi,4)
jne 0x12fd9
movq 0x18(%rdx), %rdx
movslq 0x4(%rdx), %rsi
cmpl $0x5, (%rcx,%rsi,4)
jne 0x12fd9
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 0x12fd9
movslq 0x4(%rdx), %rsi
cmpl $0x6, (%rcx,%rsi,4)
jl 0x12fd9
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 0x12fd9
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 0x12fd9
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_O2/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 0x12b75(%rip), %rcx     # 0x25be0
decl (%rcx,%r15,4)
decl (%rcx,%r12,4)
leaq 0x12966(%rip), %rax     # 0x259e0
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, 0x22f565(%rip)   # 0x242600
movq %rbx, (%rax,%rdx,8)
addl $-0x1e, 0x22f55e(%rip)  # 0x242604
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_O2/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:
pushq %rbx
movl 0x11074(%rip), %eax     # 0x24190
xorl %r8d, %r8d
testl %esi, %esi
cmovlel %r8d, %esi
leaq 0x12ab4(%rip), %r9      # 0x25be0
xorl %r10d, %r10d
cmpl %r8d, %esi
je 0x1316b
movq (%rdi,%r8,8), %r11
movslq (%r11), %rbx
cmpl %eax, (%r9,%rbx,4)
jle 0x13166
movslq 0x4(%r11), %rbx
cmpl %eax, (%r9,%rbx,4)
jle 0x13166
cmpl $0x3, 0x38(%r11)
je 0x1315c
movq 0x20(%r11), %rbx
cmpl $0x3, 0x38(%rbx)
jne 0x13166
movslq %r10d, %rbx
incl %r10d
movq %r11, (%rdx,%rbx,8)
incq %r8
jmp 0x1312f
movl %r10d, (%rcx)
popq %rbx
retq
// File: /workspace/github_c_makefile_star2_O2/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:
movq 0x10(%rdi), %rax
movq 0x20(%rax), %rdx
movslq (%rdx), %rcx
leaq 0x10d87(%rip), %rsi     # 0x25be0
pushq $0x1
popq %rax
cmpl $0x3, (%rsi,%rcx,4)
je 0x14f05
movl 0xf214(%rip), %esi      # 0x24080
leal 0x1(%rsi), %ecx
movl %ecx, 0xf20b(%rip)      # 0x24080
cmpl $0x7530, %esi           # imm = 0x7530
jl 0x14ea7
movl $0x1, 0xf1f9(%rip)      # 0x24080
xorl %esi, %esi
pushq $0x1
popq %rcx
leaq 0x273d8d(%rip), %r8     # 0x288c20
cmpq $0x100, %rsi            # imm = 0x100
je 0x14ea7
andl $0x0, (%rsi,%r8)
addq $0x4, %rsi
jmp 0x14e93
movq 0x20(%rdi), %rsi
movq 0x10(%rsi), %rsi
movq 0x20(%rsi), %r8
leaq 0x273d66(%rip), %rsi    # 0x288c20
movq 0x18(%rdi), %rdi
cmpq %r8, %rdi
je 0x14ed1
movslq 0x4(%rdi), %r9
movl %ecx, (%rsi,%r9,4)
movq 0x20(%rdi), %rdi
jmp 0x14eba
movq 0x10(%rdx), %r8
movq 0x18(%rdx), %rdi
movq 0x10(%r8), %rdx
cmpq %rdx, %rdi
je 0x14f05
movq 0x18(%rdi), %r8
movq 0x20(%rdi), %rdi
cmpq %r8, %rdi
je 0x14efe
movslq (%rdi), %r9
cmpl %ecx, (%rsi,%r9,4)
je 0x14f03
movq 0x10(%rdi), %rdi
jmp 0x14ee6
movq %r8, %rdi
jmp 0x14edd
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/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 0x10471(%rip), %rdx     # 0x259e0
movq %rax, (%rdx,%rcx,8)
movq 0x10(%rdi), %rsi
movq %rax, 0x18(%rsi)
movq 0x18(%rdi), %r8
movq %rsi, 0x10(%r8)
leaq 0x10656(%rip), %rax     # 0x25be0
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_O2/mishun[P]plantri/plantri.c
// Function: switch_edge_back
static void
switch_edge_back(EDGE *e)

/* Although switching twice is the identity on the graph, it is not on the
   data structure used. In the extend() routines the special order given
   in the initialisation is used */
{ 
    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 */
    work2=e->prev->invers; work1=work2->prev;
    e->start=work1->start; e->end=e->next->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])--;

    work2=e->prev->invers; work1=work2->prev;
    e->start=work1->start; e->end=e->next->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 0xfa1f(%rip), %rdx      # 0x259e0
movq %rax, (%rdx,%rcx,8)
movq 0x10(%rdi), %rsi
movq %rax, 0x18(%rsi)
movq 0x18(%rdi), %r8
movq %rsi, 0x10(%r8)
leaq 0xfc04(%rip), %rax      # 0x25be0
decl (%rax,%rcx,4)
movq 0x20(%rsi), %rcx
movq 0x10(%rcx), %rsi
movslq (%rsi), %r9
movl %r9d, (%rdi)
movl 0x4(%r8), %r8d
movl %r8d, 0x4(%rdi)
movq %rsi, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %rdi, 0x18(%rsi)
movq %rdi, 0x10(%rcx)
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(%rdx), %rdx
movq 0x10(%rdx), %rdi
movslq (%rdi), %r8
movl %r8d, (%rcx)
movl 0x4(%rsi), %esi
movl %esi, 0x4(%rcx)
movq %rdi, 0x10(%rcx)
movq %rdx, 0x18(%rcx)
movq %rcx, 0x18(%rdi)
movq %rcx, 0x10(%rdx)
incl (%rax,%r8,4)
retq
// File: /workspace/github_c_makefile_star2_O2/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 %r14
pushq %rbx
movl %edx, %eax
movl 0x22c5a5(%rip), %ecx    # 0x242604
xorl %edx, %edx
testl %ecx, %ecx
cmovlel %edx, %ecx
leaq 0xfc73(%rip), %r8       # 0x25ce0
cmpq %rdx, %rcx
je 0x16082
movq (%r8), %r9
movl %edx, 0x34(%r9)
incq %rdx
addq $0x8, %r8
jmp 0x1606d
imulq $0xba0, %rax, %rax      # imm = 0xBA0
leaq 0xfc50(%rip), %rcx      # 0x25ce0
movl 0xdfe5(%rip), %r8d      # 0x2407c
leal 0x2(%r8), %edx
movl %edx, 0xdfdb(%rip)      # 0x2407c
cmpl $0x752f, %r8d           # imm = 0x752F
jl 0x160de
movl $0x2, 0xdfc8(%rip)      # 0x2407c
movabsq $0x30, %r8
movl $0x2, %edx
leaq 0x22c546(%rip), %r9     # 0x242610
cmpq $0x46630, %r8           # imm = 0x46630
je 0x160de
andl $0x0, (%r8,%r9)
addq $0x40, %r8
jmp 0x160ca
addq %rcx, %rax
movl (%rsi), %r8d
xorl %r9d, %r9d
testl %r8d, %r8d
cmovlel %r9d, %r8d
xorl %r10d, %r10d
cmpq %r8, %r9
je 0x16133
movq (%rdi,%r9,8), %rbx
movslq 0x34(%rbx), %r11
movq (%rcx,%r11,8), %r14
cmpl %edx, 0x30(%r14)
je 0x1612e
leaq (%rcx,%r11,8), %r11
movslq %r10d, %r14
movq %rbx, (%rdi,%r14,8)
cmpq %rax, %r11
jae 0x1612b
movq (%r11), %rbx
movq 0x28(%rbx), %rbx
movl %edx, 0x30(%rbx)
addq $0xba0, %r11            # imm = 0xBA0
jmp 0x16113
incl %r10d
incq %r9
jmp 0x160f1
movl %r10d, (%rsi)
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O2/mishun[P]plantri/plantri.c
// Function: common_5_endpoint
static int
common_5_endpoint(EDGE *e, EDGE *e1)

/* returns 1, if the endpoints of e and e1 have a common neighbour
   with valency 5, different from their start and different from
   e->prev->end, e->next->end, e1->prev->end, e1->next->end, 0 else.
   It is assumed that the starting points of e, e1 are the same, and that

*/

/*  Alternate version:
{
    EDGE *ee;
    int k;

    RESETMARKS_V;

    ee = e->invers->next->next;
    for (k = degree[ee->start]-3; --k >= 0; ee = ee->next)
	if (degree[ee->end] == 5) MARK_V(ee->end);

    ee = e1->invers->next->next;
    for (k = degree[ee->start]-3; --k >= 0; ee = ee->next) 
        if (ISMARKED_V(ee->end)) return TRUE;

    return FALSE;
}
*/
  
{
  EDGE *run, *last;

  RESETMARKS_V;

  e=e->invers; e1=e1->invers;

  run=e->next->next;
  if (degree[run->end]==5) MARK_V(run->end);
  run=run->next;
  if (degree[run->end]==5) MARK_V(run->end);
  last=e->prev->prev;
  while (run!=last)
    { run=run->next;
    if (degree[run->end]==5) MARK_V(run->end);
    }

  run=e1->next->next;
  if (ISMARKED_V(run->end)) return 1;
  run=run->next;
  if (ISMARKED_V(run->end)) return 1;
  last=e1->prev->prev;
  while (run!=last)
    { run=run->next;
    if (ISMARKED_V(run->end)) return 1;
    }
  return 0;
}

// Assembly:
movl 0xdf40(%rip), %eax      # 0x24080
leal 0x1(%rax), %ecx
movl %ecx, 0xdf37(%rip)      # 0x24080
cmpl $0x7530, %eax           # imm = 0x7530
jl 0x16178
movl $0x1, 0xdf26(%rip)      # 0x24080
xorl %eax, %eax
pushq $0x1
popq %rcx
leaq 0x272aba(%rip), %rdx    # 0x288c20
cmpq $0x100, %rax            # imm = 0x100
je 0x16178
andl $0x0, (%rax,%rdx)
addq $0x4, %rax
jmp 0x16166
movq 0x20(%rdi), %r9
movq 0x20(%rsi), %rsi
movq 0x18(%r9), %rax
movq 0x18(%rax), %rax
movslq 0x4(%rax), %r8
leaq 0xfa4d(%rip), %rdi      # 0x25be0
cmpl $0x5, (%rdi,%r8,4)
leaq 0x272a81(%rip), %rdx    # 0x288c20
jne 0x161a5
movl %ecx, (%rdx,%r8,4)
movq 0x18(%rax), %r8
movslq 0x4(%r8), %rax
cmpl $0x5, (%rdi,%rax,4)
jne 0x161b6
movl %ecx, (%rdx,%rax,4)
pushq $0x1
popq %rax
movq 0x10(%r9), %r9
movq 0x10(%r9), %r9
cmpq %r9, %r8
je 0x161db
movq 0x18(%r8), %r8
movslq 0x4(%r8), %r10
cmpl $0x5, (%rdi,%r10,4)
jne 0x161c1
movl %ecx, (%rdx,%r10,4)
jmp 0x161c1
movq 0x18(%rsi), %rdi
movq 0x18(%rdi), %rdi
movslq 0x4(%rdi), %r8
cmpl %ecx, (%rdx,%r8,4)
je 0x16216
movq 0x18(%rdi), %rdi
movslq 0x4(%rdi), %r8
cmpl %ecx, (%rdx,%r8,4)
je 0x16216
movq 0x10(%rsi), %rsi
movq 0x10(%rsi), %rsi
cmpq %rsi, %rdi
je 0x16217
movq 0x18(%rdi), %rdi
movslq 0x4(%rdi), %r8
cmpl %ecx, (%rdx,%r8,4)
jne 0x16203
retq
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/mishun[P]plantri/plantri.c
// Function: scanmin5c3_0
static void
scanmin5c3_0(int nbtot, int nbop, EDGE **on4, int non4)

/* This is the first procedure that creates nf-3-cycles for mindeg=5
   triangulations.  It is called with a 4-connected triangulation and
   a list of the min forms of all the edges which lie on nf-4-cycles.
*/

{
   EDGE *good[MAXE],*on3[MAXE/2];
   EDGE *ext5_sw[MAXE/2];
   int i,xnbtot,xnbop,ngood,non3,next5_sw;

#ifdef PRE_FILTER_MIN5c3
    if (!(PRE_FILTER_MIN5c3)) return;
#endif
 
#ifndef FIND_EXTENSIONS_MIN5c3
#define FIND_EXTENSIONS_MIN5c3 find_extensions_min5c3
#endif
 
    FIND_EXTENSIONS_MIN5c3(nbtot,nbop,on4,non4,NULL,0,ext5_sw,&next5_sw);

    for (i = 0; i < next5_sw; ++i)
    {
        switch_edge(ext5_sw[i]);
#ifdef FAST_FILTER_MIN5c3
        if (FAST_FILTER_MIN5c3)
#endif  
        {
            non3 = 0;
            add_new_nf3_cycles(ext5_sw[i],on3,&non3);
 
            min5c3_sw_legal(ext5_sw[i],on3,non3,good,&ngood);
            if (ngood > 0
                     && canon_edge(good,ngood,degree,numbering,&xnbtot,&xnbop))
                scanmin5c3_1(xnbtot,xnbop,on3,non3);
	}
        switch_edge_back(ext5_sw[i]);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1768, %rsp           # imm = 0x1768
xorl %r14d, %r14d
leaq 0x20(%rsp), %rcx
leaq 0x1c(%rsp), %rbx
xorl %esi, %esi
xorl %edx, %edx
movq %rbx, %r8
callq 0x16448
movslq (%rbx), %r12
leaq 0x5f0(%rsp), %rbx
leaq 0xbc0(%rsp), %r15
cmpq %r12, %r14
jge 0x16436
movq 0x20(%rsp,%r14,8), %r13
movq %r13, %rdi
callq 0x15561
andl $0x0, 0xc(%rsp)
movq %r13, %rdi
movq %rbx, %rsi
leaq 0xc(%rsp), %rdx
callq 0x16637
movl 0xc(%rsp), %ebp
movq %r13, %rdi
movq %rbx, %rsi
movl %ebp, %edx
movq %r15, %rcx
leaq 0x10(%rsp), %r8
callq 0x167af
movl 0x10(%rsp), %esi
testl %esi, %esi
jle 0x16429
movq %r15, %rdi
leaq 0x18(%rsp), %rdx
leaq 0x14(%rsp), %rcx
callq 0x15978
testl %eax, %eax
je 0x16429
movl 0x18(%rsp), %edi
movl 0x14(%rsp), %esi
movq %rbx, %rdx
movl %ebp, %ecx
callq 0x16986
movq %r13, %rdi
callq 0x15fb3
incq %r14
jmp 0x163b9
addq $0x1768, %rsp           # imm = 0x1768
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mishun[P]plantri/plantri.c
// Function: scanmin5c3_1
static void
scanmin5c3_1(int nbtot, int nbop, EDGE **on3, int non3)

/* This is the first procedure that creates nf-3-cycles for mindeg=5
   triangulations.  It is called with a 3-connected triangulation and
   a list of the min forms of all the edges which lie on nf-3-cycles.
*/

{
    EDGE *good[MAXE],*ext5_sw[MAXE/2];
    int i,xnbtot,xnbop,ngood,newnon3,next5_sw;

#ifdef PRE_FILTER_MIN5c3
    if (!(PRE_FILTER_MIN5c3)) return;
#endif
 
#ifndef FIND_EXTENSIONS_MIN5c3
#define FIND_EXTENSIONS_MIN5c3 find_extensions_min5c3
#endif
 
    FIND_EXTENSIONS_MIN5c3(nbtot,nbop,NULL,0,on3,non3,ext5_sw,&next5_sw);

    if (pswitch) startpolyscan(nbtot,nbop);
    else         got_one(nbtot,nbop,3);

    for (i = 0; i < next5_sw; ++i)
    {
        switch_edge(ext5_sw[i]);
#ifdef FAST_FILTER_MIN5c3
        if (FAST_FILTER_MIN5c3)
#endif  
        {
            newnon3 = non3;
            add_new_nf3_cycles(ext5_sw[i],on3,&newnon3);
     
            min5c3_sw_legal(ext5_sw[i],on3,newnon3,good,&ngood);
            if (ngood > 0
                    && canon_edge(good,ngood,degree,numbering,&xnbtot,&xnbop))
                scanmin5c3_1(xnbtot,xnbop,on3,newnon3);
        }
        switch_edge_back(ext5_sw[i]);
    }
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x1198, %rsp           # imm = 0x1198
movl %ecx, %eax
movq %rdx, %r14
movl %esi, %ebp
movl %edi, %r15d
leaq 0x20(%rsp), %rcx
leaq 0x10(%rsp), %r8
movq %rdx, %rsi
movl %eax, 0xc(%rsp)
movl %eax, %edx
callq 0x16448
cmpb $0x1, 0xd7d8(%rip)      # 0x24198
jne 0x169ce
movl %r15d, %edi
movl %ebp, %esi
callq 0x111f3
jmp 0x169db
pushq $0x3
popq %rdx
movl %r15d, %edi
movl %ebp, %esi
callq 0x658a
movslq 0x10(%rsp), %r13
xorl %ebx, %ebx
leaq 0x5f0(%rsp), %r12
cmpq %r13, %rbx
jge 0x16a74
movq 0x20(%rsp,%rbx,8), %rbp
movq %rbp, %rdi
callq 0x15561
movl 0xc(%rsp), %eax
movl %eax, 0x8(%rsp)
movq %rbp, %rdi
movq %r14, %rsi
leaq 0x8(%rsp), %rdx
callq 0x16637
movl 0x8(%rsp), %r15d
movq %rbp, %rdi
movq %r14, %rsi
movl %r15d, %edx
movq %r12, %rcx
leaq 0x14(%rsp), %r8
callq 0x167af
movl 0x14(%rsp), %esi
testl %esi, %esi
jle 0x16a64
movq %r12, %rdi
leaq 0x1c(%rsp), %rdx
leaq 0x18(%rsp), %rcx
callq 0x15978
testl %eax, %eax
je 0x16a64
movl 0x1c(%rsp), %edi
movl 0x18(%rsp), %esi
movq %r14, %rdx
movl %r15d, %ecx
callq 0x16986
movq %rbp, %rdi
callq 0x15fb3
incq %rbx
jmp 0x169ea
addq $0x1198, %rsp           # imm = 0x1198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O2/mishun[P]plantri/plantri.c
// Function: extend_four
static void
extend_four(EDGE *ref)

/* This routine is another implementation of the 4-operation
   in Batagelj's paper.
*/
{
    register EDGE *a,*b,*start,*dummy;

    start=four_op(nv);
    b=ref->next->invers;
    a=b->next;

    degree[nv]=4; firstedge[nv]=start;

    dummy=start+1;
    start->end=dummy->start=a->start;
    (degree[a->start])++;
    a->prev=b->next=dummy;
    dummy->prev=b; dummy->next=a;

    b=b->invers; a=ref->prev;

    start+=2; /*2*/ dummy=start+1;
    start->end=dummy->start=b->start;
    firstedge[b->start]=dummy;
    b->prev=a->next=dummy;
    dummy->prev=a; dummy->next=b;

    a=a->invers; b=a->prev;
    start+=2; /*4*/ dummy=start+1;
    start->end=dummy->start=b->start;
    (degree[b->start])++;
    a->prev=b->next=dummy;
    dummy->prev=b; dummy->next=a;

    start->next=(start-4)->prev=ref;
    ref->next=start-4; ref->prev=start;
    ref->start=ref->invers->end=nv;

    nv++;
    ne+=6;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movslq 0x22a6d5(%rip), %rax    # 0x242600
imulq $0x180, %rax, %rdx      # imm = 0x180
leaq 0x22a6d7(%rip), %r8     # 0x242610
leaq (%r8,%rdx), %rcx
movq 0x18(%rdi), %rsi
movq 0x20(%rsi), %r10
movq 0x18(%r10), %r11
leaq 0xdc90(%rip), %r9       # 0x25be0
movl $0x4, (%r9,%rax,4)
leaq 0xda81(%rip), %rbx      # 0x259e0
movq %rcx, (%rbx,%rax,8)
leaq 0x40(%rdx,%r8), %rsi
movslq (%r11), %r14
movl %r14d, (%rsi)
movl %r14d, -0x3c(%rsi)
incl (%r9,%r14,4)
movq %rsi, 0x18(%r10)
movq %rsi, 0x10(%r11)
movq %r10, 0x10(%rsi)
movq %r11, 0x18(%rsi)
movq 0x20(%r10), %r10
movq 0x10(%rdi), %r11
leaq 0xc0(%rdx,%r8), %r14
movslq (%r10), %r15
movl %r15d, (%r14)
movl %r15d, -0x3c(%r14)
movq %r14, (%rbx,%r15,8)
movq %r14, 0x18(%r11)
movq %r14, 0x10(%r10)
movq %r11, 0x10(%r14)
movq %r10, 0x18(%r14)
movq 0x20(%r11), %r10
movq 0x10(%r10), %r11
leaq 0x100(%rdx,%r8), %rbx
leaq 0x140(%rdx,%r8), %rdx
movslq (%r11), %r8
movl %r8d, (%rdx)
movl %r8d, -0x3c(%rdx)
incl (%r9,%r8,4)
movq %rdx, 0x18(%r11)
movq %rdx, 0x10(%r10)
movq %r11, 0x10(%rdx)
movq %r10, 0x18(%rdx)
movq %rdi, -0x30(%rsi)
movq %rdi, -0x28(%rdx)
movq %rcx, 0x18(%rdi)
movq %rbx, 0x10(%rdi)
movq 0x20(%rdi), %rcx
movl %eax, 0x4(%rcx)
movl %eax, (%rdi)
incl %eax
movl %eax, 0x22a5f5(%rip)    # 0x242600
addl $0x6, 0x22a5f2(%rip)    # 0x242604
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O2/mishun[P]plantri/plantri.c
// Function: reduce_four
static void
reduce_four(EDGE *ref)

/* The reverse of extend_four(ref) */
{
    register EDGE *a,*b;

    a=ref->invers->prev->invers;
    b=a->prev->prev;

    a->prev=b; b->next=a; 
    firstedge[a->start]=a; (degree[a->start])--;

    a=b->invers; b=a->prev->prev;
    a->prev=b->next=ref;
    ref->next=a; ref->prev=b;
    ref->start=ref->invers->end=a->start;
    firstedge[a->start]=a;

    a=b->invers; b=a->prev->prev;
    a->prev=b; b->next=a; 
    firstedge[a->start]=a; (degree[a->start])--;

    nv--;
    ne-=6;
}

// Assembly:
movq 0x20(%rdi), %rax
movq 0x10(%rax), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq %rax, 0x18(%rcx)
movslq (%rax), %rdx
leaq 0xd50d(%rip), %rsi      # 0x259e0
movq %rax, (%rsi,%rdx,8)
leaq 0xd702(%rip), %rax      # 0x25be0
decl (%rax,%rdx,4)
movq 0x20(%rcx), %rcx
movq 0x10(%rcx), %rdx
movq 0x10(%rdx), %rdx
movq %rdi, 0x18(%rdx)
movq %rdi, 0x10(%rcx)
movq %rcx, 0x18(%rdi)
movq %rdx, 0x10(%rdi)
movslq (%rcx), %r8
movq 0x20(%rdi), %r9
movl %r8d, 0x4(%r9)
movl %r8d, (%rdi)
movq %rcx, (%rsi,%r8,8)
movq 0x20(%rdx), %rcx
movq 0x10(%rcx), %rdx
movq 0x10(%rdx), %rdx
movq %rdx, 0x10(%rcx)
movq %rcx, 0x18(%rdx)
movslq (%rcx), %rdx
decl (%rax,%rdx,4)
decl 0x22a0d1(%rip)          # 0x242600
movq %rcx, (%rsi,%rdx,8)
addl $-0x6, 0x22a0ca(%rip)   # 0x242604
retq
// File: /workspace/github_c_makefile_star2_O2/mishun[P]plantri/plantri.c
// Function: is_min4_four_centre
static int
is_min4_four_centre(int v)

/* return 1 if v is the centre of a four-reduction, 0 if not.
*/
{
    EDGE *e;

    if (degree[v] != 4) return 0;

    e = firstedge[v];
    if ((degree[e->prev->end] >= 5 && degree[e->next->end] >= 5)
	|| (degree[e->end] >= 5 && degree[e->next->next->end] >= 5))
        return 1;
    else
	return 0;
}

// Assembly:
movl %edi, %edx
leaq 0xd542(%rip), %rcx      # 0x25be0
xorl %eax, %eax
cmpl $0x4, (%rcx,%rdx,4)
jne 0x186ee
leaq 0xd333(%rip), %rax      # 0x259e0
movq (%rax,%rdx,8), %rdx
movq 0x10(%rdx), %rax
movslq 0x4(%rax), %rax
cmpl $0x5, (%rcx,%rax,4)
pushq $0x1
popq %rax
jl 0x186d0
movq 0x18(%rdx), %rsi
movslq 0x4(%rsi), %rsi
cmpl $0x4, (%rcx,%rsi,4)
jg 0x186ee
movslq 0x4(%rdx), %rsi
cmpl $0x5, (%rcx,%rsi,4)
jl 0x186ec
movq 0x18(%rdx), %rdx
movq 0x18(%rdx), %rdx
movslq 0x4(%rdx), %rdx
cmpl $0x4, (%rcx,%rdx,4)
jg 0x186ee
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O2/mishun[P]plantri/plantri.c
// Function: min4_four_centre
static int
min4_four_centre(void)

/* If there is a four-reduction, return the central vertex.
   If not, return -1.
*/
{
    int i;
    EDGE *e;

    for (i = 0; i < nv; ++i)
    if (degree[i] == 4)
    {
	e = firstedge[i];
	if ((degree[e->prev->end] >= 5 && degree[e->next->end] >= 5)
	   || (degree[e->end] >= 5 && degree[e->next->next->end] >= 5))
		return i;
    }

    return -1;
}

// Assembly:
movslq 0x229f0a(%rip), %rdx    # 0x242600
leaq 0xd2e3(%rip), %rsi      # 0x259e0
leaq 0xd4dc(%rip), %rdi      # 0x25be0
xorl %ecx, %ecx
pushq $-0x1
popq %rax
movq %rdi, %r8
cmpq %rdx, %rcx
jge 0x18765
cmpl $0x4, (%r8)
jne 0x18756
movq (%rsi), %r9
movq 0x10(%r9), %r10
movslq 0x4(%r10), %r10
cmpl $0x5, (%rdi,%r10,4)
jl 0x18738
movq 0x18(%r9), %r10
movslq 0x4(%r10), %r10
cmpl $0x4, (%rdi,%r10,4)
jg 0x18763
movslq 0x4(%r9), %r10
cmpl $0x5, (%rdi,%r10,4)
jl 0x18756
movq 0x18(%r9), %r9
movq 0x18(%r9), %r9
movslq 0x4(%r9), %r9
cmpl $0x4, (%rdi,%r9,4)
jg 0x18763
incq %rcx
addq $0x8, %rsi
addq $0x4, %r8
jmp 0x1870c
movl %ecx, %eax
retq