LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O1/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 0x10fba(%rip), %rdx     # 0x279f0
movq %rax, (%rdx,%rcx,8)
movq 0x10(%rdi), %rax
movq 0x18(%rdi), %rsi
movq %rsi, 0x18(%rax)
movq 0x18(%rdi), %rsi
movq %rax, 0x10(%rsi)
leaq 0x1119b(%rip), %rax     # 0x27bf0
decl (%rax,%rcx,4)
movq 0x20(%rsi), %rcx
movq 0x18(%rcx), %rsi
movl (%rcx), %r8d
movl %r8d, (%rdi)
movq 0x10(%rdi), %r8
movl 0x4(%r8), %r8d
movl %r8d, 0x4(%rdi)
movq %rcx, 0x10(%rdi)
movq %rsi, 0x18(%rdi)
movq %rdi, 0x18(%rcx)
movq %rdi, 0x10(%rsi)
movslq (%rcx), %rcx
incl (%rax,%rcx,4)
movq 0x20(%rdi), %rcx
movq 0x18(%rcx), %rsi
movslq (%rcx), %rdi
movq %rsi, (%rdx,%rdi,8)
movq 0x10(%rcx), %rdx
movq 0x18(%rcx), %rsi
movq %rsi, 0x18(%rdx)
movq 0x18(%rcx), %rsi
movq %rdx, 0x10(%rsi)
decl (%rax,%rdi,4)
movq 0x20(%rsi), %rdx
movq 0x18(%rdx), %rsi
movl (%rdx), %edi
movl %edi, (%rcx)
movq 0x10(%rcx), %rdi
movl 0x4(%rdi), %edi
movl %edi, 0x4(%rcx)
movq %rdx, 0x10(%rcx)
movq %rsi, 0x18(%rcx)
movq %rcx, 0x18(%rdx)
movq %rcx, 0x10(%rsi)
movslq (%rdx), %rcx
incl (%rax,%rcx,4)
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x10515(%rip), %rdx     # 0x279f0
movq %rax, (%rdx,%rcx,8)
movq 0x10(%rdi), %rax
movq 0x18(%rdi), %rsi
movq %rsi, 0x18(%rax)
movq 0x18(%rdi), %rsi
movq %rax, 0x10(%rsi)
leaq 0x106f6(%rip), %rax     # 0x27bf0
decl (%rax,%rcx,4)
movq 0x10(%rdi), %rcx
movq 0x20(%rcx), %rcx
movq 0x10(%rcx), %r8
movl (%r8), %r9d
movl %r9d, (%rdi)
movl 0x4(%rsi), %esi
movl %esi, 0x4(%rdi)
movq %r8, 0x10(%rdi)
movq %rcx, 0x18(%rdi)
movq %rdi, 0x18(%r8)
movq %rdi, 0x10(%rcx)
movslq (%r8), %rcx
incl (%rax,%rcx,4)
movq 0x20(%rdi), %rcx
movq 0x18(%rcx), %rsi
movslq (%rcx), %rdi
movq %rsi, (%rdx,%rdi,8)
movq 0x10(%rcx), %rdx
movq 0x18(%rcx), %rsi
movq %rsi, 0x18(%rdx)
movq 0x18(%rcx), %rsi
movq %rdx, 0x10(%rsi)
decl (%rax,%rdi,4)
movq 0x10(%rcx), %rdx
movq 0x20(%rdx), %rdx
movq 0x10(%rdx), %rdi
movl (%rdi), %r8d
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)
movslq (%rdi), %rcx
incl (%rax,%rcx,4)
retq
// File: /workspace/github_c_makefile_star2_O1/mishun[P]plantri/plantri.c
// Function: prune_edgelist
static void
prune_edgelist(EDGE *edge[], int *nedges, int nbtot)

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

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

// Assembly:
pushq %r15
pushq %r14
pushq %r12
pushq %rbx
leaq 0x10762(%rip), %rax     # 0x27cf0
movslq 0x22d07f(%rip), %rcx    # 0x244614
testq %rcx, %rcx
jle 0x175b3
xorl %r8d, %r8d
movq %rax, %r9
movq (%r9), %r10
movl %r8d, 0x34(%r10)
incq %r8
addq $0x8, %r9
cmpq %r8, %rcx
jne 0x175a0
movl 0xeadb(%rip), %ecx      # 0x26094
leal 0x2(%rcx), %r8d
movl %r8d, 0xead0(%rip)      # 0x26094
cmpl $0x752f, %ecx           # imm = 0x752F
jl 0x175f7
movl $0x2, 0xeabe(%rip)      # 0x26094
movl $0x30, %ecx
leaq 0x22d03e(%rip), %r8     # 0x244620
movl $0x0, (%rcx,%r8)
addq $0x40, %rcx
cmpq $0x46630, %rcx          # imm = 0x46630
jne 0x175e2
movslq (%rsi), %rcx
testq %rcx, %rcx
jle 0x17667
movl %edx, %edx
imulq $0xba0, %rdx, %rdx      # imm = 0xBA0
leaq (%rax,%rdx), %r8
xorl %r10d, %r10d
movl 0xea7e(%rip), %r11d     # 0x26094
xorl %r9d, %r9d
movq (%rdi,%r10,8), %r14
movslq 0x34(%r14), %rbx
movq (%rax,%rbx,8), %r15
cmpl %r11d, 0x30(%r15)
je 0x1765d
leaq (,%rbx,8), %r15
movslq %r9d, %r12
incl %r9d
movq %r14, (%rdi,%r12,8)
cmpq %rdx, %r15
jge 0x1765d
leaq (%rax,%rbx,8), %rbx
movq (%rbx), %r14
movq 0x28(%r14), %r14
movl %r11d, 0x30(%r14)
addq $0xba0, %rbx            # imm = 0xBA0
cmpq %r8, %rbx
jb 0x17646
incq %r10
cmpq %rcx, %r10
jne 0x17619
jmp 0x1766a
xorl %r9d, %r9d
movl %r9d, (%rsi)
popq %rbx
popq %r12
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O1/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:
pushq %r14
pushq %rbx
pushq %rax
movq %rsi, %rbx
movq %rdi, %r14
movl 0xea13(%rip), %eax      # 0x26098
leal 0x1(%rax), %ecx
movl %ecx, 0xea0a(%rip)      # 0x26098
cmpl $0x7530, %eax           # imm = 0x7530
jl 0x176b2
movl $0x1, 0xe9f9(%rip)      # 0x26098
leaq 0x27358a(%rip), %rdi    # 0x28ac30
movl $0x100, %edx            # imm = 0x100
xorl %esi, %esi
callq 0x1030
movq 0x20(%r14), %rdi
movq 0x20(%rbx), %rdx
movq 0x18(%rdi), %rax
movq 0x18(%rax), %rsi
movslq 0x4(%rsi), %r8
leaq 0x10523(%rip), %rax     # 0x27bf0
cmpl $0x5, (%rax,%r8,4)
leaq 0x273557(%rip), %rcx    # 0x28ac30
jne 0x176e6
movl 0xe9b6(%rip), %r9d      # 0x26098
movl %r9d, (%rcx,%r8,4)
movq 0x18(%rsi), %rsi
movslq 0x4(%rsi), %r8
cmpl $0x5, (%rax,%r8,4)
jne 0x17700
movl 0xe99c(%rip), %r9d      # 0x26098
movl %r9d, (%rcx,%r8,4)
movq 0x10(%rdi), %rdi
movq 0x10(%rdi), %rdi
cmpq %rdi, %rsi
je 0x1772c
movl 0xe984(%rip), %r8d      # 0x26098
movq 0x18(%rsi), %rsi
movslq 0x4(%rsi), %r9
cmpl $0x5, (%rax,%r9,4)
jne 0x17727
movl %r8d, (%rcx,%r9,4)
cmpq %rdi, %rsi
jne 0x17714
movq 0x18(%rdx), %rax
movq 0x18(%rax), %rdi
movslq 0x4(%rdi), %r8
movl 0xe95a(%rip), %esi      # 0x26098
movl $0x1, %eax
cmpl %esi, (%rcx,%r8,4)
je 0x17776
movq 0x18(%rdi), %rdi
movslq 0x4(%rdi), %r8
cmpl %esi, (%rcx,%r8,4)
je 0x17776
movq 0x10(%rdx), %rdx
movq 0x10(%rdx), %rdx
cmpq %rdx, %rdi
je 0x17774
movq 0x18(%rdi), %rdi
movslq 0x4(%rdi), %r8
cmpl %esi, (%rcx,%r8,4)
jne 0x1775f
jmp 0x17776
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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
leaq 0x20(%rsp), %rcx
leaq 0x1c(%rsp), %rbx
xorl %esi, %esi
xorl %edx, %edx
movq %rbx, %r8
callq 0x179be
movslq (%rbx), %r14
testq %r14, %r14
jle 0x179ac
xorl %r12d, %r12d
leaq 0x5f0(%rsp), %rbx
leaq 0xbc0(%rsp), %r15
movq 0x20(%rsp,%r12,8), %r13
movq %r13, %rdi
callq 0x16a28
movl $0x0, 0xc(%rsp)
movq %r13, %rdi
movq %rbx, %rsi
leaq 0xc(%rsp), %rdx
callq 0x17bda
movl 0xc(%rsp), %ebp
movq %r13, %rdi
movq %rbx, %rsi
movl %ebp, %edx
movq %r15, %rcx
leaq 0x10(%rsp), %r8
callq 0x17d5c
movl 0x10(%rsp), %esi
testl %esi, %esi
jle 0x1799c
movq %r15, %rdi
leaq 0x18(%rsp), %rdx
leaq 0x14(%rsp), %rcx
callq 0x16e7b
testl %eax, %eax
je 0x1799c
movl 0x18(%rsp), %edi
movl 0x14(%rsp), %esi
movq %rbx, %rdx
movl %ebp, %ecx
callq 0x17f6b
movq %r13, %rdi
callq 0x174cd
incq %r12
cmpq %r12, %r14
jne 0x1792e
addq $0x1768, %rsp           # imm = 0x1768
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: 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 0x179be
cmpb $0x1, 0xe203(%rip)      # 0x261a8
jne 0x17fb3
movl %r15d, %edi
movl %ebp, %esi
callq 0x123b3
jmp 0x17fc2
movl %r15d, %edi
movl %ebp, %esi
movl $0x3, %edx
callq 0x76f0
movslq 0x10(%rsp), %r13
testq %r13, %r13
jle 0x1805f
xorl %ebx, %ebx
leaq 0x5f0(%rsp), %r12
movq 0x20(%rsp,%rbx,8), %rbp
movq %rbp, %rdi
callq 0x16a28
movl 0xc(%rsp), %eax
movl %eax, 0x8(%rsp)
movq %rbp, %rdi
movq %r14, %rsi
leaq 0x8(%rsp), %rdx
callq 0x17bda
movl 0x8(%rsp), %r15d
movq %rbp, %rdi
movq %r14, %rsi
movl %r15d, %edx
movq %r12, %rcx
leaq 0x14(%rsp), %r8
callq 0x17d5c
movl 0x14(%rsp), %esi
testl %esi, %esi
jle 0x1804b
movq %r12, %rdi
leaq 0x1c(%rsp), %rdx
leaq 0x18(%rsp), %rcx
callq 0x16e7b
testl %eax, %eax
je 0x1804b
movl 0x1c(%rsp), %edi
movl 0x18(%rsp), %esi
movq %r14, %rdx
movl %r15d, %ecx
callq 0x17f6b
movq %rbp, %rdi
callq 0x174cd
incq %rbx
cmpq %rbx, %r13
jne 0x17fda
addq $0x1198, %rsp           # imm = 0x1198
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: legal_5_min5_reduction
static int
legal_5_min5_reduction(EDGE *e, EDGE *nf4cycleedges[], int numnf4cycleedges)

/* Checks whether the edge given is a legal reference edge for a 5-reduction
   in the minimum valency 5 connectivity 4 case, that is:

   (i) e->start has degree 5 (note that this way in case of both
        endpoints valency 5 the routine has to be called for e and
        e->invers due to the asymmetric behaviour of (iii)) 
   (ii) The two endpoints of e->next, e->prev have valency at least 6
   (iii) The two endpoints of e->next, e->prev have a common neighbour with
         valency 5 different from e->start, e->end, so especially
         e->next, e->prev, e->invers->next, e->invers->prev all are on
         nf-4-cycles.  
  (iv) after doing the 5-reduction e->next->next and e->prev->prev 
       will not be on 4-cycles

   Returns 1 in case it is a legal reduction, 0 otherwise. Assumes the
   non-existence of nf-3-cycles.  nf4cycleedges[0..numnf4cycleedges-1] 
   are the min forms of all edges on nf-4-cycles.
*/

{
  EDGE *dummy;

  if (degree[e->start]!=5) return 0;

  RESETMARKS;
  for (numnf4cycleedges--; numnf4cycleedges>=0; numnf4cycleedges--) 
    MARKLO(nf4cycleedges[numnf4cycleedges]);

  if (!ISMARKEDLO(e->next->min) || !ISMARKEDLO(e->prev->min)) return 0;
  dummy=e->invers;
  if (!ISMARKEDLO(dummy->next->min) || !ISMARKEDLO(dummy->prev->min)) return 0;
  if (!common_5_endpoint(e->next,e->prev)) return 0;
  if (will_be_on_nf4_5red(e)) return 0;

  return 1;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movslq (%rdi), %rax
leaq 0xfb71(%rip), %rcx      # 0x27bf0
xorl %ebx, %ebx
cmpl $0x5, (%rcx,%rax,4)
jne 0x18141
movq %rdi, %r14
movl 0xe000(%rip), %eax      # 0x26094
leal 0x2(%rax), %ecx
movl %ecx, 0xdff7(%rip)      # 0x26094
cmpl $0x752f, %eax           # imm = 0x752F
jl 0x180cd
movl $0x2, 0xdfe6(%rip)      # 0x26094
movl $0x30, %eax
leaq 0x22c566(%rip), %rcx    # 0x244620
movl $0x0, (%rax,%rcx)
addq $0x40, %rax
cmpq $0x46630, %rax          # imm = 0x46630
jne 0x180ba
testl %edx, %edx
jle 0x180ed
movl 0xdfbd(%rip), %eax      # 0x26094
movl %edx, %ecx
incq %rcx
movq -0x10(%rsi,%rcx,8), %rdx
movl %eax, 0x30(%rdx)
decq %rcx
cmpq $0x1, %rcx
jg 0x180dc
movq 0x18(%r14), %rdi
movq 0x28(%rdi), %rcx
movl 0xdf99(%rip), %eax      # 0x26094
cmpl %eax, 0x30(%rcx)
jne 0x18141
movq 0x10(%r14), %rsi
movq 0x28(%rsi), %rcx
cmpl %eax, 0x30(%rcx)
jne 0x18141
movq 0x20(%r14), %rcx
movq 0x18(%rcx), %rdx
movq 0x28(%rdx), %rdx
cmpl %eax, 0x30(%rdx)
jne 0x18141
movq 0x10(%rcx), %rcx
movq 0x28(%rcx), %rcx
cmpl %eax, 0x30(%rcx)
jne 0x18141
callq 0x17675
testl %eax, %eax
je 0x18141
movq %r14, %rdi
callq 0x1814b
movl %eax, %ebx
xorl $0x1, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/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 %rbp
pushq %r15
pushq %r14
pushq %rbx
movslq 0x22afd1(%rip), %rax    # 0x244610
leaq (%rax,%rax,2), %rdx
shlq $0x7, %rdx
leaq 0x22afd2(%rip), %r8     # 0x244620
leaq (%r8,%rdx), %rcx
movq 0x18(%rdi), %rsi
movq 0x20(%rsi), %r10
movq 0x18(%r10), %r11
leaq 0xe58b(%rip), %r9       # 0x27bf0
movl $0x4, (%r9,%rax,4)
leaq 0xe37c(%rip), %rbx      # 0x279f0
movq %rcx, (%rbx,%rax,8)
leaq 0x40(%rdx,%r8), %rsi
movl (%r11), %ebp
movl %ebp, (%rsi)
movl %ebp, -0x3c(%rsi)
movslq (%r11), %r14
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
movl (%r10), %ebp
movl %ebp, (%r14)
movl %ebp, -0x3c(%r14)
movslq (%r10), %r15
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
movl (%r11), %r8d
movl %r8d, (%rdx)
movl %r8d, -0x3c(%rdx)
movslq (%r11), %r8
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, 0x22aee9(%rip)    # 0x244610
addl $0x6, 0x22aee6(%rip)    # 0x244614
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xe053(%rip), %rsi      # 0x27bf0
decl (%rsi,%rdx,4)
leaq 0xde49(%rip), %r8       # 0x279f0
movq %rax, (%r8,%rdx,8)
movq 0x20(%rcx), %rax
movq 0x10(%rax), %rcx
movq 0x10(%rcx), %rcx
movq %rdi, 0x18(%rcx)
movq %rdi, 0x10(%rax)
movq %rax, 0x18(%rdi)
movq %rcx, 0x10(%rdi)
movl (%rax), %edx
movq 0x20(%rdi), %r9
movl %edx, 0x4(%r9)
movl %edx, (%rdi)
movslq (%rax), %rdx
movq %rax, (%r8,%rdx,8)
movq 0x20(%rcx), %rax
movq 0x10(%rax), %rcx
movq 0x10(%rcx), %rcx
movq %rcx, 0x10(%rax)
movq %rax, 0x18(%rcx)
movslq (%rax), %rcx
decl (%rsi,%rcx,4)
decl 0x22aa16(%rip)          # 0x244610
movq %rax, (%r8,%rcx,8)
addl $-0x6, 0x22aa0f(%rip)   # 0x244614
retq
// File: /workspace/github_c_makefile_star2_O1/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 0xde7c(%rip), %rcx      # 0x27bf0
xorl %eax, %eax
cmpl $0x4, (%rcx,%rdx,4)
jne 0x19dcb
leaq 0xdc6d(%rip), %rax      # 0x279f0
movq (%rax,%rdx,8), %rdx
movq 0x10(%rdx), %rax
movslq 0x4(%rax), %rax
cmpl $0x5, (%rcx,%rax,4)
jl 0x19da8
movq 0x18(%rdx), %rax
movslq 0x4(%rax), %rsi
movl $0x1, %eax
cmpl $0x4, (%rcx,%rsi,4)
jg 0x19dcb
movslq 0x4(%rdx), %rax
cmpl $0x5, (%rcx,%rax,4)
jl 0x19dc9
movq 0x18(%rdx), %rax
movq 0x18(%rax), %rax
movslq 0x4(%rax), %rdx
movl $0x1, %eax
cmpl $0x4, (%rcx,%rdx,4)
jg 0x19dcb
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/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 0x22a83d(%rip), %rcx    # 0x244610
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testq %rcx, %rcx
jle 0x19e45
leaq 0xdc0c(%rip), %rsi      # 0x279f0
leaq 0xde05(%rip), %rdi      # 0x27bf0
xorl %edx, %edx
movq %rdi, %r8
cmpl $0x4, (%r8)
jne 0x19e35
movq (%rsi), %r9
movq 0x10(%r9), %r10
movslq 0x4(%r10), %r10
cmpl $0x5, (%rdi,%r10,4)
jl 0x19e17
movq 0x18(%r9), %r10
movslq 0x4(%r10), %r10
cmpl $0x4, (%rdi,%r10,4)
jg 0x19e46
movslq 0x4(%r9), %r10
cmpl $0x5, (%rdi,%r10,4)
jl 0x19e35
movq 0x18(%r9), %r9
movq 0x18(%r9), %r9
movslq 0x4(%r9), %r9
cmpl $0x4, (%rdi,%r9,4)
jg 0x19e46
incq %rdx
addq $0x8, %rsi
addq $0x4, %r8
cmpq %rdx, %rcx
jne 0x19df0
retq
movl %edx, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mishun[P]plantri/plantri.c
// Function: reduce_five
static void
reduce_five(EDGE *ref)

/* The reverse of extend_five(). */
{
    EDGE *a,*b,*dummy;

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

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

    a=b->invers->prev->prev->invers; b=a->prev->prev;
    a->prev=ref; ref->next=a; b->next=ref; 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; 
    (degree[a->start])--;
    firstedge[a->start]=a;

    nv--;
    ne-=6;
}

// Assembly:
movq 0x18(%rdi), %rax
movq 0x20(%rdi), %rcx
movq 0x18(%rax), %rax
movq 0x10(%rcx), %rdx
movq %rax, 0x18(%rdx)
movq %rax, 0x10(%rcx)
movq %rcx, 0x18(%rax)
movq %rdx, 0x10(%rax)
movl (%rcx), %esi
movq 0x20(%rax), %r8
movl %esi, 0x4(%r8)
movl %esi, (%rax)
movslq (%rcx), %rcx
leaq 0xdb65(%rip), %rax      # 0x27bf0
incl (%rax,%rcx,4)
movq 0x20(%rdx), %rcx
movq 0x10(%rcx), %rdx
movq 0x10(%rdx), %rdx
movq %rdx, 0x10(%rcx)
movq %rcx, 0x18(%rdx)
movslq (%rcx), %rsi
decl (%rax,%rsi,4)
movslq (%rcx), %rsi
leaq 0xd93e(%rip), %r8       # 0x279f0
movq %rcx, (%r8,%rsi,8)
movq 0x20(%rdx), %rcx
movq 0x10(%rcx), %rcx
movq 0x10(%rcx), %rcx
movq 0x20(%rcx), %rcx
movq 0x10(%rcx), %rdx
movq 0x10(%rdx), %rdx
movq %rdi, 0x10(%rcx)
movq %rcx, 0x18(%rdi)
movq %rdi, 0x18(%rdx)
movq %rdx, 0x10(%rdi)
movl (%rcx), %esi
movq 0x20(%rdi), %r9
movl %esi, 0x4(%r9)
movl %esi, (%rdi)
movslq (%rcx), %rsi
movq %rcx, (%r8,%rsi,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)
movslq (%rcx), %rax
decl 0x22a4fc(%rip)          # 0x244610
movq %rcx, (%r8,%rax,8)
addl $-0x6, 0x22a4f5(%rip)   # 0x244614
retq
// File: /workspace/github_c_makefile_star2_O1/mishun[P]plantri/plantri.c
// Function: extend_S
static void
extend_S(EDGE *ref)

/* This routine is the implementation of the S-operation in Batagelj's paper.
   It inserts 3 new vertices in triangular form into a triangle on the right
   hand side of ref */

{
    register EDGE *a,*b,*start;
    int dummy;

    start=S_op(nv);

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

    degree[nv]=degree[nv+1]=degree[nv+2]=4;
    
    dummy=ref->start;
    degree[dummy]+=2; 
    (start+10)->start=(start+11)->end=(start+8)->start=(start+9)->end=dummy;

    dummy=ref->end;
    degree[dummy]+=2; 
    (start+12)->start=(start+13)->end=(start+14)->start=(start+15)->end=dummy;

    dummy=a->end;
    degree[dummy]+=2; 
    (start+6)->start=(start+7)->end=(start+16)->start=(start+17)->end=dummy;

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

    ref->next=start+10; (start+10)->prev=ref;
    a->next=start+14; (start+14)->prev=a;
    b->next=start+6; (start+6)->prev=b;

    ref=ref->invers;
    ref->prev=start+12; (start+12)->next=ref;
    a=a->invers;
    a->prev=start+16; (start+16)->next=a;
    b=b->invers;
    b->prev=start+8; (start+8)->next=b;

    nv+=3;
    ne+=18;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
movslq 0x22a4df(%rip), %rax    # 0x244610
leaq (%rax,%rax,8), %rsi
shlq $0x7, %rsi
movq 0x20(%rdi), %rcx
movq 0x10(%rcx), %rdx
movq 0x20(%rdx), %rcx
movq 0x10(%rcx), %rcx
leaq 0xdaa0(%rip), %r10      # 0x27bf0
movl $0x4, %r8d
movl %r8d, 0x8(%r10,%rax,4)
movl %r8d, 0x4(%r10,%rax,4)
movl %r8d, (%r10,%rax,4)
movslq (%rdi), %r11
addl $0x2, (%r10,%r11,4)
leaq 0x22a4ad(%rip), %rbx    # 0x244620
leaq (%rsi,%rbx), %r14
addq $0xc000, %r14           # imm = 0xC000
movl %r11d, 0x244(%r14)
leaq 0xc200(%rsi,%rbx), %r8
movl %r11d, (%r8)
movl %r11d, 0xc4(%r8)
leaq (%rsi,%rbx), %r9
addq $0xc280, %r9            # imm = 0xC280
movl %r11d, (%r9)
movslq 0x4(%rdi), %r11
addl $0x2, (%r10,%r11,4)
movl %r11d, 0x144(%r9)
leaq (%rsi,%rbx), %r15
addq $0xc380, %r15           # imm = 0xC380
movl %r11d, (%r15)
movl %r11d, -0x3c(%r15)
leaq (%rsi,%rbx), %r12
addq $0xc300, %r12           # imm = 0xC300
movl %r11d, (%r12)
movslq 0x4(%rdx), %r11
addl $0x2, (%r10,%r11,4)
movl %r11d, 0x144(%r12)
leaq (%rsi,%rbx), %r10
addq $0xc400, %r10           # imm = 0xC400
movl %r11d, (%r10)
movl %r11d, -0x3c(%r8)
leaq 0xc180(%rsi,%rbx), %r13
movl %r11d, (%r13)
leaq 0xc040(%rsi,%rbx), %r11
leaq 0xd7dc(%rip), %rbp      # 0x279f0
movq %r11, (%rbp,%rax,8)
movq %r14, 0x8(%rbp,%rax,8)
leaq 0xc080(%rsi,%rbx), %rsi
movq %rsi, 0x10(%rbp,%rax,8)
movq %r9, 0x18(%rdi)
movq %rdi, -0x70(%r12)
movq %r15, 0x18(%rdx)
movq %rdx, -0x70(%r10)
movq %r13, 0x18(%rcx)
movq %rcx, 0x10(%r13)
movq 0x20(%rdi), %rsi
movq %r12, 0x10(%rsi)
movq %rsi, 0x18(%r12)
movq 0x20(%rdx), %rdx
movq %r10, 0x10(%rdx)
movq %rdx, 0x18(%r10)
movq 0x20(%rcx), %rcx
movq %r8, 0x10(%rcx)
movq %rcx, -0x68(%r9)
addl $0x3, %eax
movl %eax, 0x22a39e(%rip)    # 0x244610
addl $0x12, 0x22a39b(%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_S
static void
reduce_S(EDGE *ref)

/* This routine is the implementation of the inverse S-operation in
   Batagelj's paper. It removes the triangle. 
*/
{
    register EDGE *a,*b;

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

    firstedge[ref->start]=ref;
    degree[ref->start]-=2;
    firstedge[a->start]=a;
    degree[a->start]-=2;
    firstedge[b->start]=b;
    degree[b->start]-=2;

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

    nv-=3;
    ne-=18;
}

// Assembly:
movq 0x20(%rdi), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x20(%rax), %rcx
movq 0x10(%rcx), %rcx
movq 0x10(%rcx), %rcx
movq 0x10(%rcx), %rcx
movslq (%rdi), %rdx
leaq 0xd758(%rip), %rsi      # 0x27bf0
addl $-0x2, (%rsi,%rdx,4)
leaq 0xd54d(%rip), %r8       # 0x279f0
movq %rdi, (%r8,%rdx,8)
movslq (%rax), %rdx
movq %rax, (%r8,%rdx,8)
addl $-0x2, (%rsi,%rdx,4)
movslq (%rcx), %rdx
movq %rcx, (%r8,%rdx,8)
addl $-0x2, (%rsi,%rdx,4)
movq 0x20(%rcx), %rdx
movq %rdx, 0x18(%rdi)
movq %rdi, 0x10(%rdx)
movq 0x20(%rdi), %rdx
movq %rdx, 0x18(%rax)
movq %rax, 0x10(%rdx)
movq 0x20(%rax), %rax
movq %rax, 0x18(%rcx)
movq %rcx, 0x10(%rax)
addl $-0x3, 0x22a128(%rip)   # 0x244610
addl $-0x12, 0x22a125(%rip)  # 0x244614
retq
// File: /workspace/github_c_makefile_star2_O1/mishun[P]plantri/plantri.c
// Function: is_min4_four
static int
is_min4_four(EDGE *ref)

/* Test if ref (known to be an edge!) is the reference edge of a
   legal four-reduction in the min4 case. 
   Return 1 if it is, and 0 if it isn't.
*/
{
    int w;
    EDGE *e,*elast;

    if (degree[ref->start] != 4) return 0;
    if (degree[ref->prev->end] == 4 || degree[ref->next->end] == 4) return 0;

    w = ref->next->next->end;
    if (degree[w] == 4) return 1;
    e = ref->invers;
    elast = e->prev;
    for (e = e->next->next; e != elast; e = e->next)
	if (e->end == w) return 0;

    return 1;
}

// Assembly:
movslq (%rdi), %rcx
leaq 0xd6f6(%rip), %rdx      # 0x27bf0
xorl %eax, %eax
cmpl $0x4, (%rdx,%rcx,4)
jne 0x1a51e
movq 0x10(%rdi), %rcx
movslq 0x4(%rcx), %rcx
cmpl $0x4, (%rdx,%rcx,4)
je 0x1a51e
movq 0x18(%rdi), %rcx
movslq 0x4(%rcx), %rsi
cmpl $0x4, (%rdx,%rsi,4)
jne 0x1a51f
retq
movq 0x18(%rcx), %rcx
movslq 0x4(%rcx), %rcx
cmpl $0x4, (%rdx,%rcx,4)
jne 0x1a533
movl $0x1, %eax
retq
movq 0x20(%rdi), %rsi
movq 0x10(%rsi), %rdx
movq 0x18(%rsi), %rsi
movq 0x18(%rsi), %rsi
cmpq %rdx, %rsi
je 0x1a52d
cmpl %ecx, 0x4(%rsi)
jne 0x1a53f
jmp 0x1a51e
// File: /workspace/github_c_makefile_star2_O1/mishun[P]plantri/plantri.c
// Function: extend3
static void 
extend3(EDGE *e)

/* inserts a vertex with valence 3 in the triangle on the right hand
   side (->next direction) of the edge e */
{
    register EDGE *work1, *work2, *work3;

    work1 = STAR3(nv);
    work2 = work1+1;
    work3 = work2+1;
    firstedge[nv] = work3+1;

/* work1 starts at the beginning of e: */

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

/* Now go one edge further around the triangle and the same once more */

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

    e = e->invers->prev;

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

    degree[nv] = 3;

/* Now I have 6 edges and one vertex more */

    ne += 6; 
    nv++;
}

// Assembly:
movslq 0x22a0ba(%rip), %rax    # 0x244610
leal (,%rax,8), %ecx
movslq %ecx, %r8
shlq $0x6, %r8
leaq 0x22a0b5(%rip), %r9     # 0x244620
leaq (%r8,%r9), %rcx
addq $0x200, %rcx            # imm = 0x200
leaq 0x240(%r8,%r9), %rdx
leaq 0xd46b(%rip), %rsi      # 0x279f0
movq %rdx, (%rsi,%rax,8)
movl (%rdi), %esi
movq -0x60(%rcx), %r10
movl %esi, 0x4(%r10)
leaq 0x180(%r8,%r9), %r10
movl %esi, -0x80(%rcx)
movq 0x18(%rdi), %rsi
movq %r10, 0x10(%rsi)
movq %rsi, -0x68(%rcx)
movq %rdi, -0x70(%rcx)
movq %r10, 0x18(%rdi)
movslq (%rdi), %r10
leaq 0xd634(%rip), %rsi      # 0x27bf0
incl (%rsi,%r10,4)
addq %r9, %r8
addq $0x1c0, %r8             # imm = 0x1C0
movq 0x20(%rdi), %rdi
movq 0x10(%rdi), %rdi
movl (%rdi), %r9d
movq -0x60(%rdx), %r10
movl %r9d, 0x4(%r10)
movl %r9d, -0x80(%rdx)
movq 0x18(%rdi), %r9
movq %r8, 0x10(%r9)
movq %r9, -0x68(%rdx)
movq %rdi, -0x70(%rdx)
movq %r8, 0x18(%rdi)
movslq (%rdi), %r8
incl (%rsi,%r8,4)
movq 0x20(%rdi), %rdi
movq 0x10(%rdi), %rdi
movl (%rdi), %r8d
movq -0x20(%rdx), %r9
movl %r8d, 0x4(%r9)
movl %r8d, -0x40(%rdx)
movq 0x18(%rdi), %r8
movq %rcx, 0x10(%r8)
movq %r8, -0x28(%rdx)
movq %rdi, -0x30(%rdx)
movq %rcx, 0x18(%rdi)
movslq (%rdi), %rcx
incl (%rsi,%rcx,4)
addl $0x6, 0x229fe0(%rip)    # 0x244614
movl $0x3, (%rsi,%rax,4)
incl %eax
movl %eax, 0x229fcd(%rip)    # 0x244610
retq
// File: /workspace/github_c_makefile_star2_O1/mishun[P]plantri/plantri.c
// Function: disk_threeconn
static int
disk_threeconn(EDGE *e)

/* Checks whether a triangulation of a disk is 3-connected. This is
   the case if and only if there are no chords (except for K3).
   The edge e must have the triangulation on the right and the outer
   face on the left. 
   Returns TRUE if 3-connected, FALSE otherwise. */
{
    EDGE *run, *run2, *buffer;

    if (nv == 3) return FALSE;   /* K3 has connectivity 2 */

    RESETMARKS_V;

/* It is correct to do the marking and the running and checking in one
   wash, since a chord will be detected when the second of the endpoints 
   is reached */

    MARK_V(e->start); MARK_V(e->end);
 
    for (buffer=e->invers, run=buffer->next; run != e; 
                     buffer=run->invers, run=buffer->next)
      { MARK_V(run->end);
        for (run2=run->next; run2 != buffer; run2=run2->next)
            if (ISMARKED_V(run2->end)) return FALSE;
      }

    return TRUE;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
xorl %ebx, %ebx
cmpl $0x3, 0x2295fc(%rip)    # 0x244610
je 0x1b0a1
movq %rdi, %r14
movl 0xb075(%rip), %eax      # 0x26098
leal 0x1(%rax), %ecx
movl %ecx, 0xb06c(%rip)      # 0x26098
cmpl $0x7530, %eax           # imm = 0x7530
jl 0x1b050
movl $0x1, 0xb05b(%rip)      # 0x26098
leaq 0x26fbec(%rip), %rdi    # 0x28ac30
movl $0x100, %edx            # imm = 0x100
xorl %esi, %esi
callq 0x1030
movl 0xb042(%rip), %eax      # 0x26098
movslq (%r14), %rdx
leaq 0x26fbd0(%rip), %rcx    # 0x28ac30
movl %eax, (%rcx,%rdx,4)
movslq 0x4(%r14), %rdx
movl %eax, (%rcx,%rdx,4)
movq 0x20(%r14), %rdx
movq 0x18(%rdx), %rsi
cmpq %r14, %rsi
je 0x1b09c
movslq 0x4(%rsi), %rdi
movl %eax, (%rcx,%rdi,4)
movq %rsi, %rdi
movq 0x18(%rdi), %rdi
cmpq %rdx, %rdi
je 0x1b096
movslq 0x4(%rdi), %r8
cmpl %eax, (%rcx,%r8,4)
jne 0x1b081
jmp 0x1b0a1
movq 0x20(%rsi), %rdx
jmp 0x1b06e
movl $0x1, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/mishun[P]plantri/plantri.c
// Function: reduce_bip_P
static void
reduce_bip_P(EDGE *ref)

/* This routine is the implementation of the inverse P-operation in Batagelj's 
   paper. It removes the two new vertices -- nv and nv+1. The reference edge 
   ref is c->e and when c and e are removed becomes x->e

        a
       / \
  x---b---c---e  The edge c-->e is the reference edge
       \ /
        d

*/
{
    EDGE *a, *b, *c, *d;
     /* 4 edges forming the square whose inside is removed (except ref) */

    a=ref->invers->next;
    b=ref->invers->prev;
    c=a->invers->next->next->next->invers;
    d=b->invers->prev->prev->prev->invers;

    degree[a->end]-=2;  degree[b->end]-=2;

    ref->start=ref->invers->end=c->start;
    firstedge[ref->start]=ref;
    ref->next=d; d->prev=ref;
    ref->prev=c; c->next=ref;

    a=a->invers; c=c->invers;
    a->next=c; c->prev=a; firstedge[a->start]=a;

    b=b->invers; d=d->invers;
    b->prev=d; d->next=b; firstedge[b->start]=b;

    nv -= 2;
    ne -= 12;
}

// Assembly:
movq 0x20(%rdi), %rcx
movq 0x10(%rcx), %rax
movq 0x18(%rcx), %rdx
movq 0x20(%rdx), %rsi
movq 0x18(%rsi), %rsi
movq 0x18(%rsi), %rsi
movq 0x18(%rsi), %rsi
movq 0x20(%rsi), %rsi
movq 0x20(%rax), %r8
movq 0x10(%r8), %r8
movq 0x10(%r8), %r8
movq 0x10(%r8), %r8
movq 0x20(%r8), %r8
movslq 0x4(%rdx), %r9
leaq 0xa8c6(%rip), %r10      # 0x27bf0
addl $-0x2, (%r10,%r9,4)
movslq 0x4(%rax), %r9
addl $-0x2, (%r10,%r9,4)
movslq (%rsi), %r9
movl %r9d, 0x4(%rcx)
movl %r9d, (%rdi)
leaq 0xa6a7(%rip), %rcx      # 0x279f0
movq %rdi, (%rcx,%r9,8)
movq %r8, 0x18(%rdi)
movq %rdi, 0x10(%r8)
movq %rsi, 0x10(%rdi)
movq %rdi, 0x18(%rsi)
movq 0x20(%rdx), %rdx
movq 0x20(%rsi), %rsi
movq %rsi, 0x18(%rdx)
movq %rdx, 0x10(%rsi)
movslq (%rdx), %rsi
movq %rdx, (%rcx,%rsi,8)
movq 0x20(%rax), %rax
movq 0x20(%r8), %rdx
movq %rdx, 0x10(%rax)
movq %rax, 0x18(%rdx)
movslq (%rax), %rdx
addl $-0x2, 0x227282(%rip)   # 0x244610
movq %rax, (%rcx,%rdx,8)
addl $-0xc, 0x22727b(%rip)   # 0x244614
retq
// File: /workspace/github_c_makefile_star2_O1/mishun[P]plantri/plantri.c
// Function: update_nft_P
static void
update_nft_P(triangle nft[], int numnft, EDGE *ref,
                triangle newnft[], int *newnumnft)

/* Make new list of non-facial triangles after a P-extension. */
{
    EDGE *refmin,*e,*elast;
    int i,k,w;

    refmin = ref->min;

  /* Remove triangles that include ref */
    k = 0;
    for (i = 0; i < numnft; ++i)
        if (nft[i].e1 != refmin && nft[i].e2 != refmin && nft[i].e3 != refmin)
            newnft[k++] = nft[i];

  /* Add new nfts formed by a shortcut if present.  There must be at
     least two nfts already for this to be possible. */

    if (k >= 2)
    {
        w = ref->next->end;
        elast = ref->invers->next->invers;
        for (e = elast->next->next->next->next; e != elast; e = e->next)
            if (e->end == w) break;
        if (e != elast)
        {
            newnft[k].e1 = e->min;
            newnft[k].e2 = ref->prev->min;
            newnft[k].e3 = ref->next->min;
            newnft[k+1].e1 = e->min;
            newnft[k+1].e2 = ref->next->next->invers->prev->min;
            newnft[k+1].e3 = ref->next->next->invers->next->min;
	    k += 2;
        }
    }
    *newnumnft = k;
}

// Assembly:
pushq %r14
pushq %rbx
testl %esi, %esi
jle 0x1d7f5
movq 0x28(%rdx), %r9
movl %esi, %eax
shlq $0x3, %rax
leaq (%rax,%rax,2), %rsi
xorl %r10d, %r10d
xorl %eax, %eax
cmpq %r9, (%rdi,%r10)
je 0x1d7ea
cmpq %r9, 0x8(%rdi,%r10)
je 0x1d7ea
cmpq %r9, 0x10(%rdi,%r10)
je 0x1d7ea
leaq (%rdi,%r10), %r11
movslq %eax, %rbx
incl %eax
leaq (%rbx,%rbx,2), %rbx
movq 0x10(%r11), %r14
movq %r14, 0x10(%rcx,%rbx,8)
movups (%r11), %xmm0
movups %xmm0, (%rcx,%rbx,8)
addq $0x18, %r10
cmpq %r10, %rsi
jne 0x1d7b8
jmp 0x1d7f7
xorl %eax, %eax
cmpl $0x2, %eax
jl 0x1d879
movq 0x18(%rdx), %rsi
movq 0x20(%rdx), %r9
movl 0x4(%rsi), %edi
movq 0x18(%r9), %r9
movq 0x20(%r9), %r9
movq 0x18(%r9), %r10
movq 0x18(%r10), %r10
movq 0x18(%r10), %r10
movq 0x18(%r10), %r10
cmpq %r9, %r10
je 0x1d879
cmpl %edi, 0x4(%r10)
jne 0x1d81b
movq 0x28(%r10), %rdi
movl %eax, %r9d
leaq (%r9,%r9,2), %r9
movq %rdi, (%rcx,%r9,8)
movq 0x10(%rdx), %rdx
movq 0x28(%rdx), %rdx
movq %rdx, 0x8(%rcx,%r9,8)
movq 0x28(%rsi), %rdx
movq %rdx, 0x10(%rcx,%r9,8)
movq %rdi, 0x18(%rcx,%r9,8)
movq 0x18(%rsi), %rdx
movq 0x20(%rdx), %rdx
movq 0x10(%rdx), %rsi
movq 0x28(%rsi), %rsi
movq %rsi, 0x20(%rcx,%r9,8)
movq 0x18(%rdx), %rdx
movq 0x28(%rdx), %rdx
movq %rdx, 0x28(%rcx,%r9,8)
addl $0x2, %eax
movl %eax, (%r8)
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O1/mishun[P]plantri/plantri.c
// Function: is_bip_P
static int
is_bip_P(EDGE *e)

/* Return 1 if e is the reference edge of a valid P reduction,
   otherwise 0.  It must be that e is an edge of the graph. */
{
    int z;
    EDGE *e1,*ew,*ewlast;

    if (degree[e->start] != 4 || degree[e->end] == 4) return 0;
    if (degree[e->next->end] == 4 || degree[e->prev->end] == 4) return 0;
    e1 = e->next->next;
    if (degree[e1->end] != 4) return 0;
    z = e1->invers->next->next->end;
    if (degree[z] == 4) return 1;
    ew = e->invers;
    ewlast = ew->prev;
    for (ew = ew->next->next; ew != ewlast; ew = ew->next)
        if (ew->end == z) break;
    if (ew != ewlast) return 0;
    else              return 1;
}

// Assembly:
movslq (%rdi), %rdx
leaq 0xa1f7(%rip), %rcx      # 0x27bf0
xorl %eax, %eax
cmpl $0x4, (%rcx,%rdx,4)
jne 0x1da72
movslq 0x4(%rdi), %rdx
cmpl $0x4, (%rcx,%rdx,4)
je 0x1da72
movq 0x18(%rdi), %rdx
movslq 0x4(%rdx), %rsi
cmpl $0x4, (%rcx,%rsi,4)
je 0x1da72
movq 0x10(%rdi), %rsi
movslq 0x4(%rsi), %rsi
cmpl $0x4, (%rcx,%rsi,4)
je 0x1da72
movq 0x18(%rdx), %rdx
movslq 0x4(%rdx), %rsi
cmpl $0x4, (%rcx,%rsi,4)
jne 0x1da72
movq 0x20(%rdx), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rax
movslq 0x4(%rax), %rdx
movl $0x1, %eax
cmpl $0x4, (%rcx,%rdx,4)
je 0x1da72
movq 0x20(%rdi), %rax
movq 0x10(%rax), %rcx
movq 0x18(%rax), %rsi
movq 0x18(%rsi), %rsi
cmpq %rcx, %rsi
je 0x1da6a
cmpl %edx, 0x4(%rsi)
jne 0x1da5c
xorl %eax, %eax
cmpq %rcx, %rsi
sete %al
retq
// File: /workspace/github_c_makefile_star2_O1/mishun[P]plantri/plantri.c
// Function: has_bip_P
static EDGE*
has_bip_P(void)

/* If the graph has a legal P-reduction return an example;
   otherwise return NULL. */
{

    int i,j,w,z;
    EDGE *e,*e1,*ez,*ezlast;

    for (i = 0; i < nv; ++i)
    if (degree[i] == 4)
    {
	e = firstedge[i];
	j = 0;
	if (degree[e->end] == 4) {e1 = e; ++j;} e=e->next;
	if (degree[e->end] == 4) {e1 = e; ++j;} e=e->next;
	if (degree[e->end] == 4) {e1 = e; ++j;} e=e->next;
	if (degree[e->end] == 4) {e1 = e; ++j;}
	if (j != 1) continue;

	e = e1->next->next;
        
	w = e->end;
	z = e1->invers->next->next->end;
        
	if (degree[z] != 4)
	{
            ezlast = ez = firstedge[z];
            do
            {
                if (ez->end == w) break;
                ez = ez->next;
            } while (ez != ezlast);
            if (ez->end == w) continue;
	}

	return e;
    }
    return NULL;
}

// Assembly:
movslq 0x226b96(%rip), %rcx    # 0x244610
testq %rcx, %rcx
jle 0x1db55
leaq 0xa166(%rip), %rdx      # 0x27bf0
leaq 0x9f5f(%rip), %rsi      # 0x279f0
xorl %edi, %edi
cmpl $0x4, (%rdx,%rdi,4)
jne 0x1db49
movq (%rsi,%rdi,8), %rax
movslq 0x4(%rax), %r9
xorl %r10d, %r10d
cmpl $0x4, (%rdx,%r9,4)
sete %r10b
cmoveq %rax, %r8
movq 0x18(%rax), %rax
movslq 0x4(%rax), %r9
leal 0x1(%r10), %r11d
cmpl $0x4, (%rdx,%r9,4)
cmovnel %r10d, %r11d
cmoveq %rax, %r8
movq 0x18(%rax), %rax
movslq 0x4(%rax), %r9
xorl %r10d, %r10d
cmpl $0x4, (%rdx,%r9,4)
cmoveq %rax, %r8
sete %r10b
addl %r11d, %r10d
movq 0x18(%rax), %rax
movslq 0x4(%rax), %r9
xorl %r11d, %r11d
cmpl $0x4, (%rdx,%r9,4)
sete %r11b
cmoveq %rax, %r8
addl %r10d, %r11d
cmpl $0x1, %r11d
jne 0x1db49
movq 0x18(%r8), %rax
movq 0x20(%r8), %r9
movq 0x18(%rax), %rax
movq 0x18(%r9), %r9
movq 0x18(%r9), %r9
movslq 0x4(%r9), %r10
cmpl $0x4, (%rdx,%r10,4)
je 0x1db57
movl 0x4(%rax), %r9d
movq (%rsi,%r10,8), %r11
movq %r11, %r10
cmpl %r9d, 0x4(%r10)
je 0x1db43
movq 0x18(%r10), %r10
cmpq %r11, %r10
jne 0x1db34
cmpl %r9d, 0x4(%r10)
jne 0x1db57
incq %rdi
cmpq %rcx, %rdi
jne 0x1da93
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O1/mishun[P]plantri/plantri.c
// Function: reduce_bip_Q
static void
reduce_bip_Q(EDGE *ref)

/* This routine is the implementation of the inverse Q-operation in
   Batagelj's paper. It removes the new vertex nv. 
*/
{

    EDGE *a,*b,*c,*d,*x;

    x=ref->next;
    a=ref->invers->next->invers;
    b=a->next->next->next;

    c=x->invers->prev->invers;
    d=c->prev->prev->prev;
    
    firstedge[a->start]=a;
    firstedge[c->start]=c;

    ref->start=ref->invers->end=x->start=x->invers->end=b->end;
    (degree[b->end])+=2;
    (degree[a->start])-=2; (degree[c->start])-=2; 
    
    b->prev=a; a->next=b;
    c->prev=d; d->next=c;

    b=b->invers; d=d->invers;

    b->next=ref; ref->prev=b;
    d->prev=x; x->next=d;

    nv--;
    ne-=6;
}

// Assembly:
movq 0x18(%rdi), %rax
movq 0x20(%rdi), %rcx
movq 0x18(%rcx), %rcx
movq 0x20(%rcx), %rcx
movq 0x18(%rcx), %rdx
movq 0x18(%rdx), %rdx
movq 0x18(%rdx), %rdx
movq 0x20(%rax), %rsi
movq 0x10(%rsi), %rsi
movq 0x20(%rsi), %rsi
movq 0x10(%rsi), %r8
movq 0x10(%r8), %r8
movq 0x10(%r8), %r8
movslq (%rcx), %r9
leaq 0x9c4e(%rip), %r10      # 0x279f0
movq %rcx, (%r10,%r9,8)
movslq (%rsi), %r9
movq %rsi, (%r10,%r9,8)
movl 0x4(%rdx), %r9d
movq 0x20(%rax), %r10
movl %r9d, 0x4(%r10)
movl %r9d, (%rax)
movq 0x20(%rdi), %r10
movl %r9d, 0x4(%r10)
movl %r9d, (%rdi)
movslq 0x4(%rdx), %r9
leaq 0x9e1e(%rip), %r10      # 0x27bf0
addl $0x2, (%r10,%r9,4)
movslq (%rcx), %r9
addl $-0x2, (%r10,%r9,4)
movslq (%rsi), %r9
addl $-0x2, (%r10,%r9,4)
movq %rcx, 0x10(%rdx)
movq %rdx, 0x18(%rcx)
movq %r8, 0x10(%rsi)
movq %rsi, 0x18(%r8)
movq 0x20(%rdx), %rcx
movq 0x20(%r8), %rdx
movq %rdi, 0x18(%rcx)
movq %rcx, 0x10(%rdi)
movq %rax, 0x10(%rdx)
movq %rdx, 0x18(%rax)
decl 0x2267fb(%rip)          # 0x244610
addl $-0x6, 0x2267f8(%rip)   # 0x244614
retq
// File: /workspace/github_c_makefile_star2_O1/mishun[P]plantri/plantri.c
// Function: legal_P1_reduction_nf4
static int
legal_P1_reduction_nf4(EDGE *e)

/* checks whether the edge e characterizes a legal P1-reduction.
   Version for 3-connected quadrangulations without non-facial 4-cycles.
   Returns 1 if yes, 0 otherwise.

   It is assumed that edge->start has degree 3, and that both the side
   vertices edge->next->end and edge->prev->end have degree at least 4.
*/

{
    EDGE *e1,*e1last,*e2,*e2last;

    if (degree[e->end] == 3) return TRUE;

    RESETMARKS_V;

    e1 = e->invers;
    e1last = e1->prev;
    e1 = e1->next->next;
    do
    {
	MARK_V(e1->end);
	e1 = e1->next;
    } while (e1 != e1last);

    e1 = e->next->invers->prev->invers;
    e1last = e1->prev;
    e1 = e1->next;
    do
    {
	e2last = e1->invers;
	e2 = e2last->next;
	do
	{
	    if (ISMARKED_V(e2->end)) return FALSE;
	    e2 = e2->next;
	} while (e2 != e2last);
        
        e1 = e1->next;
    } while (e1 != e1last);

    return TRUE;
}

// Assembly:
pushq %r14
pushq %rbx
pushq %rax
movslq 0x4(%rdi), %rax
leaq 0x9344(%rip), %rcx      # 0x27bf0
movl $0x1, %ebx
cmpl $0x3, (%rcx,%rax,4)
je 0x1e95e
movq %rdi, %r14
movl 0x77d4(%rip), %eax      # 0x26098
leal 0x1(%rax), %ecx
movl %ecx, 0x77cb(%rip)      # 0x26098
cmpl $0x7530, %eax           # imm = 0x7530
jl 0x1e8f1
movl $0x1, 0x77ba(%rip)      # 0x26098
leaq 0x26c34b(%rip), %rdi    # 0x28ac30
movl $0x100, %edx            # imm = 0x100
xorl %esi, %esi
callq 0x1030
movq 0x20(%r14), %rax
movq 0x10(%rax), %rdx
movq 0x18(%rax), %rax
movq 0x18(%rax), %rsi
movl 0x7791(%rip), %eax      # 0x26098
leaq 0x26c322(%rip), %rcx    # 0x28ac30
movslq 0x4(%rsi), %rdi
movl %eax, (%rcx,%rdi,4)
movq 0x18(%rsi), %rsi
cmpq %rdx, %rsi
jne 0x1e90e
movq 0x18(%r14), %rdx
movq 0x20(%rdx), %rdx
movq 0x10(%rdx), %rdx
movq 0x20(%rdx), %rsi
movq 0x10(%rsi), %rdx
movq 0x18(%rsi), %rsi
movq 0x20(%rsi), %rdi
movq 0x18(%rdi), %r8
movslq 0x4(%r8), %r9
cmpl %eax, (%rcx,%r9,4)
je 0x1e95c
movq 0x18(%r8), %r8
cmpq %rdi, %r8
jne 0x1e93e
movq 0x18(%rsi), %rsi
cmpq %rdx, %rsi
jne 0x1e936
jmp 0x1e95e
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq