LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/mishun[P]plantri/plantri.c
// Function: insert_edge_tri
static void
insert_edge_tri(EDGE *e)

/* inserts the edge previously deleted -- e may not have been modified in
   the meantime and the map must look exactly like it looked before deleting 
   it. On the left hand side of e there must be a triangle after inserting e */
{
    int newfacesize;
    EDGE *run;

    ne +=2;

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

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

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

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

    run=e->next;
    run->left_facesize=3;
    run->invers->next->left_facesize=3;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl 0x2389b6(%rip), %eax    # 0x25a624
addl $0x2, %eax
movl %eax, 0x2389ad(%rip)    # 0x25a624
movq -0x8(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movslq (%rax), %rcx
leaq 0x1bf5b(%rip), %rax     # 0x3dc00
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
leaq 0x1bf4e(%rip), %rax     # 0x3dc00
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movslq (%rax), %rcx
leaq 0x1bf11(%rip), %rax     # 0x3dc00
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
leaq 0x1bf04(%rip), %rax     # 0x3dc00
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rax
movl 0x38(%rax), %eax
movl %eax, -0xc(%rbp)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x8(%rbp), %rax
je 0x21d4f
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x38(%rax)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x21d29
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl $0x3, 0x38(%rax)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x18(%rax), %rax
movl $0x3, 0x38(%rax)
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mishun[P]plantri/plantri.c
// Function: twoconn
static int
twoconn(EDGE *e)

/* tests whether the graph obtained by deleting EDGE e is still 2-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 2-connected
   before.  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).

   If there is a 1-cut, it cannot be e->start or e->end (otherwise
   it was a 1-cut before), but they must be in different components, (same
   reason), so v=e->prev->end MUST be the cutvertex.
   It is checked whether v is contained in the face on the right hand side
   of e (before deleting). 

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

{
    EDGE *run, *end;
    int v;

    end = e->next;
    if (end == e->prev) return 0;
    end = end->invers;

    v = e->prev->end;
    if (degree[v] == 2) return 1;

    for (run = e->invers->prev; run != end; run = run->invers->prev)
        if (run->end == v) return 0;

   return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x10(%rcx), %rax
jne 0x2388b
movl $0x0, -0x4(%rbp)
jmp 0x23909
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x4(%rax), %eax
movl %eax, -0x24(%rbp)
movslq -0x24(%rbp), %rcx
leaq 0x1a350(%rip), %rax     # 0x3dc00
cmpl $0x2, (%rax,%rcx,4)
jne 0x238bf
movl $0x1, -0x4(%rbp)
jmp 0x23909
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
je 0x23902
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
cmpl -0x24(%rbp), %eax
jne 0x238ee
movl $0x0, -0x4(%rbp)
jmp 0x23909
jmp 0x238f0
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x238cf
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl %edx, -0x14(%rbp)
cmpl $0x1, -0x14(%rbp)
jne 0x24fca
jmp 0x25132
leaq 0x18d2f(%rip), %rax     # 0x3dd00
movq %rax, -0x28(%rbp)
movslq -0x14(%rbp), %rcx
leaq 0x18d20(%rip), %rax     # 0x3dd00
imulq $0xba0, %rcx, %rcx      # imm = 0xBA0
addq %rcx, %rax
movq %rax, -0x38(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl 0x235626(%rip), %eax    # 0x25a624
jge 0x2501d
movl -0x18(%rbp), %ecx
movq -0x28(%rbp), %rax
movslq -0x18(%rbp), %rdx
movq (%rax,%rdx,8), %rax
movl %ecx, 0x34(%rax)
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x24ff5
movl 0x17061(%rip), %eax     # 0x3c084
addl $0x2, %eax
movl %eax, 0x17058(%rip)     # 0x3c084
cmpl $0x7530, %eax           # imm = 0x7530
jle 0x25073
movl $0x2, 0x17047(%rip)     # 0x3c084
movl $0x0, -0x3c(%rbp)
cmpl $0x1198, -0x3c(%rbp)    # imm = 0x1198
jge 0x25071
movslq -0x3c(%rbp), %rcx
leaq 0x2355d8(%rip), %rax    # 0x25a630
shlq $0x6, %rcx
addq %rcx, %rax
movl $0x0, 0x30(%rax)
movl -0x3c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x3c(%rbp)
jmp 0x25044
jmp 0x25073
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movl $0x0, -0x20(%rbp)
movl $0x0, -0x18(%rbp)
movl -0x18(%rbp), %eax
cmpl -0x1c(%rbp), %eax
jge 0x25129
movq -0x28(%rbp), %rax
movq -0x8(%rbp), %rcx
movslq -0x18(%rbp), %rdx
movq (%rcx,%rdx,8), %rcx
movslq 0x34(%rcx), %rcx
shlq $0x3, %rcx
addq %rcx, %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movq (%rax), %rax
movl 0x30(%rax), %eax
cmpl 0x16fbf(%rip), %eax     # 0x3c084
je 0x25119
movq -0x8(%rbp), %rax
movslq -0x18(%rbp), %rcx
movq (%rax,%rcx,8), %rdx
movq -0x8(%rbp), %rax
movl -0x20(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x20(%rbp)
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x30(%rbp), %rax
cmpq -0x38(%rbp), %rax
jae 0x25117
movl 0x16f8b(%rip), %ecx     # 0x3c084
movq -0x30(%rbp), %rax
movq (%rax), %rax
movq 0x28(%rax), %rax
movl %ecx, 0x30(%rax)
movq -0x30(%rbp), %rax
addq $0xba0, %rax            # imm = 0xBA0
movq %rax, -0x30(%rbp)
jmp 0x250e9
jmp 0x25119
jmp 0x2511b
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
jmp 0x2508a
movl -0x20(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x1790, %rsp           # imm = 0x1790
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
movq -0x10(%rbp), %rdx
movl -0x14(%rbp), %ecx
leaq -0x1760(%rbp), %r10
xorl %eax, %eax
movl %eax, %r8d
xorl %r9d, %r9d
leaq -0x1778(%rbp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x261c0
movl $0x0, -0x1764(%rbp)
movl -0x1764(%rbp), %eax
cmpl -0x1778(%rbp), %eax
jge 0x25f36
movslq -0x1764(%rbp), %rax
movq -0x1760(%rbp,%rax,8), %rdi
callq 0x23c60
movl $0x0, -0x1774(%rbp)
movslq -0x1764(%rbp), %rax
movq -0x1760(%rbp,%rax,8), %rdi
leaq -0x1190(%rbp), %rsi
leaq -0x1774(%rbp), %rdx
callq 0x26220
movslq -0x1764(%rbp), %rax
movq -0x1760(%rbp,%rax,8), %rdi
leaq -0x1190(%rbp), %rsi
movl -0x1774(%rbp), %edx
leaq -0xbc0(%rbp), %rcx
leaq -0x1770(%rbp), %r8
callq 0x26500
cmpl $0x0, -0x1770(%rbp)
jle 0x25f0e
leaq -0xbc0(%rbp), %rdi
movl -0x1770(%rbp), %esi
leaq 0x17d2f(%rip), %rdx     # 0x3dc00
leaq 0x17e28(%rip), %rcx     # 0x3dd00
leaq -0x1768(%rbp), %r8
leaq -0x176c(%rbp), %r9
callq 0x244e0
cmpl $0x0, %eax
je 0x25f0e
movl -0x1768(%rbp), %edi
movl -0x176c(%rbp), %esi
leaq -0x1190(%rbp), %rdx
movl -0x1774(%rbp), %ecx
callq 0x26770
movslq -0x1764(%rbp), %rax
movq -0x1760(%rbp,%rax,8), %rdi
callq 0x24c40
movl -0x1764(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1764(%rbp)
jmp 0x25e33
addq $0x1790, %rsp           # imm = 0x1790
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mishun[P]plantri/plantri.c
// Function: has_min5c4_sw
static int
has_min5c4_sw(EDGE **on4, int non4)

/* on4[0..non4-1] is a complete list of all (min) edges in nf-4-cycles.
   Return TRUE if there is a valid switch-reduction.  Assume no nf-3-cycles.
*/

{
    EDGE *e;
    int i;

    for (i = 0; i < non4; ++i)
    {
	e = on4[i];

	if (degree[e->start] >= 6 && degree[e->end] >= 6
            				    && wont_be_on_nf_4_cycle(e))
	    return TRUE;
    }

    return FALSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x10(%rbp)
movl %esi, -0x14(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0x14(%rbp), %eax
jge 0x25fbb
movq -0x10(%rbp), %rax
movslq -0x24(%rbp), %rcx
movq (%rax,%rcx,8), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movslq (%rax), %rcx
leaq 0x17c84(%rip), %rax     # 0x3dc00
cmpl $0x6, (%rax,%rcx,4)
jl 0x25fae
movq -0x20(%rbp), %rax
movslq 0x4(%rax), %rcx
leaq 0x17c6f(%rip), %rax     # 0x3dc00
cmpl $0x6, (%rax,%rcx,4)
jl 0x25fae
movq -0x20(%rbp), %rdi
callq 0x25a70
cmpl $0x0, %eax
je 0x25fae
movl $0x1, -0x4(%rbp)
jmp 0x25fc2
jmp 0x25fb0
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x25f56
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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
movq %rsp, %rbp
subq $0x11c0, %rsp           # imm = 0x11C0
movl %edi, -0x4(%rbp)
movl %esi, -0x8(%rbp)
movq %rdx, -0x10(%rbp)
movl %ecx, -0x14(%rbp)
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
movq -0x10(%rbp), %r8
movl -0x14(%rbp), %r9d
leaq -0x1190(%rbp), %r10
xorl %eax, %eax
movl %eax, %edx
xorl %ecx, %ecx
leaq -0x11a8(%rbp), %rax
movq %r10, (%rsp)
movq %rax, 0x8(%rsp)
callq 0x261c0
cmpl $0x0, 0x159e9(%rip)     # 0x3c1a8
je 0x267ce
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
callq 0x1c350
jmp 0x267de
movl -0x4(%rbp), %edi
movl -0x8(%rbp), %esi
movl $0x3, %edx
callq 0x8080
movl $0x0, -0x1194(%rbp)
movl -0x1194(%rbp), %eax
cmpl -0x11a8(%rbp), %eax
jge 0x268e1
movslq -0x1194(%rbp), %rax
movq -0x1190(%rbp,%rax,8), %rdi
callq 0x23c60
movl -0x14(%rbp), %eax
movl %eax, -0x11a4(%rbp)
movslq -0x1194(%rbp), %rax
movq -0x1190(%rbp,%rax,8), %rdi
movq -0x10(%rbp), %rsi
leaq -0x11a4(%rbp), %rdx
callq 0x26220
movslq -0x1194(%rbp), %rax
movq -0x1190(%rbp,%rax,8), %rdi
movq -0x10(%rbp), %rsi
movl -0x11a4(%rbp), %edx
leaq -0xbc0(%rbp), %rcx
leaq -0x11a0(%rbp), %r8
callq 0x26500
cmpl $0x0, -0x11a0(%rbp)
jle 0x268b9
leaq -0xbc0(%rbp), %rdi
movl -0x11a0(%rbp), %esi
leaq 0x17381(%rip), %rdx     # 0x3dc00
leaq 0x1747a(%rip), %rcx     # 0x3dd00
leaq -0x1198(%rbp), %r8
leaq -0x119c(%rbp), %r9
callq 0x244e0
cmpl $0x0, %eax
je 0x268b9
movl -0x1198(%rbp), %edi
movl -0x119c(%rbp), %esi
movq -0x10(%rbp), %rdx
movl -0x11a4(%rbp), %ecx
callq 0x26770
movslq -0x1194(%rbp), %rax
movq -0x1190(%rbp,%rax,8), %rdi
callq 0x24c40
movl -0x1194(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1194(%rbp)
jmp 0x267e8
addq $0x11c0, %rsp           # imm = 0x11C0
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mishun[P]plantri/plantri.c
// Function: is_3banglecenter_notdouble
static int
is_3banglecenter_notdouble(EDGE *e)

/* returns 1 if it is the center of a 3bangle and after the edge is
   switched it is not in a double edge, 0 else */
 
{
  EDGE *run, *last, *dummy;
  int end;
 
  RESETMARKS_V;
 
  dummy=e->next->invers;
  e=e->prev->invers;
  end=e->start;
 
  last=dummy->prev;
  run=dummy->next->next;
  if (run->end == end) return 0;
  MARK_V(run->end);
  while (run!=last)
    { run=run->next;
      if (run->end == end) return 0;
      MARK_V(run->end);
    }
 
  run=e->next;
  last=e->prev->prev;
  if (ISMARKED_V(run->end)) return 1;
  while (run!=last)
    { run=run->next;
      if (ISMARKED_V(run->end)) return 1;
    }
 
  return 0;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl 0x15622(%rip), %eax     # 0x3c090
addl $0x1, %eax
movl %eax, 0x15619(%rip)     # 0x3c090
cmpl $0x7530, %eax           # imm = 0x7530
jle 0x26ab4
movl $0x1, 0x15608(%rip)     # 0x3c090
movl $0x0, -0x30(%rbp)
cmpl $0x40, -0x30(%rbp)
jge 0x26ab2
movslq -0x30(%rbp), %rcx
leaq 0x27a1a0(%rip), %rax    # 0x2a0c40
movl $0x0, (%rax,%rcx,4)
movl -0x30(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x30(%rbp)
jmp 0x26a8f
jmp 0x26ab4
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
cmpl -0x2c(%rbp), %eax
jne 0x26b11
movl $0x0, -0x4(%rbp)
jmp 0x26bf4
movl 0x15579(%rip), %edx     # 0x3c090
movq -0x18(%rbp), %rax
movslq 0x4(%rax), %rcx
leaq 0x27a11a(%rip), %rax    # 0x2a0c40
movl %edx, (%rax,%rcx,4)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
je 0x26b71
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
cmpl -0x2c(%rbp), %eax
jne 0x26b57
movl $0x0, -0x4(%rbp)
jmp 0x26bf4
movl 0x15533(%rip), %edx     # 0x3c090
movq -0x18(%rbp), %rax
movslq 0x4(%rax), %rcx
leaq 0x27a0d4(%rip), %rax    # 0x2a0c40
movl %edx, (%rax,%rcx,4)
jmp 0x26b29
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movslq 0x4(%rax), %rcx
leaq 0x27a0a4(%rip), %rax    # 0x2a0c40
movl (%rax,%rcx,4), %eax
cmpl 0x154eb(%rip), %eax     # 0x3c090
jne 0x26bb0
movl $0x1, -0x4(%rbp)
jmp 0x26bf4
jmp 0x26bb2
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
je 0x26bed
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movslq 0x4(%rax), %rcx
leaq 0x27a069(%rip), %rax    # 0x2a0c40
movl (%rax,%rcx,4), %eax
cmpl 0x154b0(%rip), %eax     # 0x3c090
jne 0x26beb
movl $0x1, -0x4(%rbp)
jmp 0x26bf4
jmp 0x26bb2
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mishun[P]plantri/plantri.c
// Function: wont_be_on_nf_3_cycle
static int
wont_be_on_nf_3_cycle(EDGE *e)
 
/* returns 1 if after switching e won't be on an nf 3-cycle. */
 
{
  EDGE *run, *last, *dummy;
 
  RESETMARKS_V;
  dummy=e->next->invers;
  last=dummy->prev;
  run=dummy->next->next;
  MARK_V(run->end);
  while (run!=last)
    { run=run->next;
      MARK_V(run->end);
    }
 
  e=e->prev->invers;
  run=e->next;
  last=e->prev->prev;
  if (ISMARKED_V(run->end)) return 0;
  while (run!=last)
    { run=run->next;
      if (ISMARKED_V(run->end)) return 0;
    }
 
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl 0x15482(%rip), %eax     # 0x3c090
addl $0x1, %eax
movl %eax, 0x15479(%rip)     # 0x3c090
cmpl $0x7530, %eax           # imm = 0x7530
jle 0x26c54
movl $0x1, 0x15468(%rip)     # 0x3c090
movl $0x0, -0x2c(%rbp)
cmpl $0x40, -0x2c(%rbp)
jge 0x26c52
movslq -0x2c(%rbp), %rcx
leaq 0x27a000(%rip), %rax    # 0x2a0c40
movl $0x0, (%rax,%rcx,4)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x26c2f
jmp 0x26c54
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movl 0x1540a(%rip), %edx     # 0x3c090
movq -0x18(%rbp), %rax
movslq 0x4(%rax), %rcx
leaq 0x279fab(%rip), %rax    # 0x2a0c40
movl %edx, (%rax,%rcx,4)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
je 0x26cc8
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movl 0x153dc(%rip), %edx     # 0x3c090
movq -0x18(%rbp), %rax
movslq 0x4(%rax), %rcx
leaq 0x279f7d(%rip), %rax    # 0x2a0c40
movl %edx, (%rax,%rcx,4)
jmp 0x26c98
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movslq 0x4(%rax), %rcx
leaq 0x279f3d(%rip), %rax    # 0x2a0c40
movl (%rax,%rcx,4), %eax
cmpl 0x15384(%rip), %eax     # 0x3c090
jne 0x26d17
movl $0x0, -0x4(%rbp)
jmp 0x26d5b
jmp 0x26d19
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
je 0x26d54
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movslq 0x4(%rax), %rcx
leaq 0x279f02(%rip), %rax    # 0x2a0c40
movl (%rax,%rcx,4), %eax
cmpl 0x15349(%rip), %eax     # 0x3c090
jne 0x26d52
movl $0x0, -0x4(%rbp)
jmp 0x26d5b
jmp 0x26d19
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rdx
movq -0x10(%rbp), %rax
movslq (%rax), %rcx
leaq 0x1424a(%rip), %rax     # 0x3da00
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movslq (%rax), %rcx
leaq 0x14438(%rip), %rax     # 0x3dc00
movl (%rax,%rcx,4), %edx
addl $-0x1, %edx
leaq 0x1442b(%rip), %rax     # 0x3dc00
movl %edx, (%rax,%rcx,4)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl (%rax), %ecx
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movl %ecx, 0x4(%rax)
movq -0x8(%rbp), %rax
movl %ecx, (%rax)
movq -0x10(%rbp), %rdx
movq -0x10(%rbp), %rax
movslq (%rax), %rcx
leaq 0x141b7(%rip), %rax     # 0x3da00
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rdx
movq -0x10(%rbp), %rax
movslq (%rax), %rcx
leaq 0x1416d(%rip), %rax     # 0x3da00
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movslq (%rax), %rcx
leaq 0x1435b(%rip), %rax     # 0x3dc00
movl (%rax,%rcx,4), %edx
addl $-0x1, %edx
leaq 0x1434e(%rip), %rax     # 0x3dc00
movl %edx, (%rax,%rcx,4)
movl 0x230d65(%rip), %eax    # 0x25a620
addl $-0x1, %eax
movl %eax, 0x230d5c(%rip)    # 0x25a620
movl 0x230d5a(%rip), %eax    # 0x25a624
subl $0x6, %eax
movl %eax, 0x230d51(%rip)    # 0x25a624
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x8(%rbp)
movslq -0x8(%rbp), %rcx
leaq 0x13fce(%rip), %rax     # 0x3dc00
cmpl $0x4, (%rax,%rcx,4)
je 0x29c44
movl $0x0, -0x4(%rbp)
jmp 0x29ccb
movslq -0x8(%rbp), %rcx
leaq 0x13db1(%rip), %rax     # 0x3da00
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movslq 0x4(%rax), %rcx
leaq 0x13f96(%rip), %rax     # 0x3dc00
cmpl $0x5, (%rax,%rcx,4)
jl 0x29c89
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movslq 0x4(%rax), %rcx
leaq 0x13f7d(%rip), %rax     # 0x3dc00
cmpl $0x5, (%rax,%rcx,4)
jge 0x29cbb
movq -0x10(%rbp), %rax
movslq 0x4(%rax), %rcx
leaq 0x13f68(%rip), %rax     # 0x3dc00
cmpl $0x5, (%rax,%rcx,4)
jl 0x29cc4
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rax
movslq 0x4(%rax), %rcx
leaq 0x13f4b(%rip), %rax     # 0x3dc00
cmpl $0x5, (%rax,%rcx,4)
jl 0x29cc4
movl $0x1, -0x4(%rbp)
jmp 0x29ccb
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl 0x23093c(%rip), %eax    # 0x25a620
jge 0x29d90
movslq -0x8(%rbp), %rcx
leaq 0x13f0b(%rip), %rax     # 0x3dc00
cmpl $0x4, (%rax,%rcx,4)
jne 0x29d80
movslq -0x8(%rbp), %rcx
leaq 0x13cf6(%rip), %rax     # 0x3da00
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movslq 0x4(%rax), %rcx
leaq 0x13edb(%rip), %rax     # 0x3dc00
cmpl $0x5, (%rax,%rcx,4)
jl 0x29d44
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movslq 0x4(%rax), %rcx
leaq 0x13ec2(%rip), %rax     # 0x3dc00
cmpl $0x5, (%rax,%rcx,4)
jge 0x29d76
movq -0x10(%rbp), %rax
movslq 0x4(%rax), %rcx
leaq 0x13ead(%rip), %rax     # 0x3dc00
cmpl $0x5, (%rax,%rcx,4)
jl 0x29d7e
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rax
movslq 0x4(%rax), %rcx
leaq 0x13e90(%rip), %rax     # 0x3dc00
cmpl $0x5, (%rax,%rcx,4)
jl 0x29d7e
movl -0x8(%rbp), %eax
movl %eax, -0x4(%rbp)
jmp 0x29d97
jmp 0x29d80
jmp 0x29d82
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x29cdb
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mishun[P]plantri/plantri.c
// Function: degree5_vertex
static int
degree5_vertex(void)

/* Return a vertex of degree 5, -1 if there are none */
{
    int i;

    for (i = 0; i < nv; ++i)
	if (degree[i] == 5) return 1;

    return -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl 0x22ff7c(%rip), %eax    # 0x25a620
jge 0x2a6cd
movslq -0x8(%rbp), %rcx
leaq 0x1354f(%rip), %rax     # 0x3dc00
cmpl $0x5, (%rax,%rcx,4)
jne 0x2a6c0
movl $0x1, -0x4(%rbp)
jmp 0x2a6d4
jmp 0x2a6c2
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x2a69b
movl $0xffffffff, -0x4(%rbp) # imm = 0xFFFFFFFF
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x8(%rbp), %rdx
movq -0x8(%rbp), %rax
movslq (%rax), %rcx
leaq 0x12ee6(%rip), %rax     # 0x3da00
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movslq (%rax), %rcx
leaq 0x130d4(%rip), %rax     # 0x3dc00
movl (%rax,%rcx,4), %edx
subl $0x2, %edx
leaq 0x130c7(%rip), %rax     # 0x3dc00
movl %edx, (%rax,%rcx,4)
movq -0x10(%rbp), %rdx
movq -0x10(%rbp), %rax
movslq (%rax), %rcx
leaq 0x12eb2(%rip), %rax     # 0x3da00
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movslq (%rax), %rcx
leaq 0x130a0(%rip), %rax     # 0x3dc00
movl (%rax,%rcx,4), %edx
subl $0x2, %edx
leaq 0x13093(%rip), %rax     # 0x3dc00
movl %edx, (%rax,%rcx,4)
movq -0x18(%rbp), %rdx
movq -0x18(%rbp), %rax
movslq (%rax), %rcx
leaq 0x12e7e(%rip), %rax     # 0x3da00
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
movslq (%rax), %rcx
leaq 0x1306c(%rip), %rax     # 0x3dc00
movl (%rax,%rcx,4), %edx
subl $0x2, %edx
leaq 0x1305f(%rip), %rax     # 0x3dc00
movl %edx, (%rax,%rcx,4)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rcx
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rcx, 0x10(%rax)
movl 0x22fa16(%rip), %eax    # 0x25a620
subl $0x3, %eax
movl %eax, 0x22fa0d(%rip)    # 0x25a620
movl 0x22fa0b(%rip), %eax    # 0x25a624
subl $0x12, %eax
movl %eax, 0x22fa02(%rip)    # 0x25a624
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mishun[P]plantri/plantri.c
// Function: has_3_four_centres
static int
has_3_four_centres(void)

/* Return 1 if there are at least three vertices which are centres
   for a four-reduction (min4 case).  Return 0 otherwise.
*/
{
    EDGE *e;
    int v,count;

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

    return count >= 3;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, -0x18(%rbp)
movl 0x22efef(%rip), %eax    # 0x25a620
movl %eax, -0x14(%rbp)
movl -0x14(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x14(%rbp)
cmpl $0x0, %eax
jl 0x2b6f2
movslq -0x14(%rbp), %rcx
leaq 0x125af(%rip), %rax     # 0x3dc00
cmpl $0x4, (%rax,%rcx,4)
jne 0x2b6ed
movslq -0x14(%rbp), %rcx
leaq 0x1239a(%rip), %rax     # 0x3da00
movq (%rax,%rcx,8), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movslq 0x4(%rax), %rcx
leaq 0x1257f(%rip), %rax     # 0x3dc00
cmpl $0x5, (%rax,%rcx,4)
jl 0x2b6a0
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movslq 0x4(%rax), %rcx
leaq 0x12566(%rip), %rax     # 0x3dc00
cmpl $0x5, (%rax,%rcx,4)
jge 0x2b6d2
movq -0x10(%rbp), %rax
movslq 0x4(%rax), %rcx
leaq 0x12551(%rip), %rax     # 0x3dc00
cmpl $0x5, (%rax,%rcx,4)
jl 0x2b6eb
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rax
movslq 0x4(%rax), %rcx
leaq 0x12534(%rip), %rax     # 0x3dc00
cmpl $0x5, (%rax,%rcx,4)
jl 0x2b6eb
movl -0x18(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x18(%rbp)
cmpl $0x3, %eax
jne 0x2b6e9
movl $0x1, -0x4(%rbp)
jmp 0x2b701
jmp 0x2b6eb
jmp 0x2b6ed
jmp 0x2b634
cmpl $0x3, -0x18(%rbp)
setge %al
andb $0x1, %al
movzbl %al, %eax
movl %eax, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movslq (%rax), %rcx
leaq 0x124da(%rip), %rax     # 0x3dc00
cmpl $0x4, (%rax,%rcx,4)
je 0x2b738
movl $0x0, -0x4(%rbp)
jmp 0x2b800
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movslq 0x4(%rax), %rcx
leaq 0x124b5(%rip), %rax     # 0x3dc00
cmpl $0x4, (%rax,%rcx,4)
je 0x2b76a
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movslq 0x4(%rax), %rcx
leaq 0x1249c(%rip), %rax     # 0x3dc00
cmpl $0x4, (%rax,%rcx,4)
jne 0x2b776
movl $0x0, -0x4(%rbp)
jmp 0x2b800
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rax
movl 0x4(%rax), %eax
movl %eax, -0x14(%rbp)
movslq -0x14(%rbp), %rcx
leaq 0x1246d(%rip), %rax     # 0x3dc00
cmpl $0x4, (%rax,%rcx,4)
jne 0x2b7a2
movl $0x1, -0x4(%rbp)
jmp 0x2b800
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
je 0x2b7f9
movq -0x20(%rbp), %rax
movl 0x4(%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x2b7e9
movl $0x0, -0x4(%rbp)
jmp 0x2b800
jmp 0x2b7eb
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x2b7ca
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mishun[P]plantri/plantri.c
// Function: reduce3
static void 
reduce3(EDGE *e)

/* deletes a vertex with valence 3 in the triangle on the right hand side
 (->next-direction) of the edge e. It is not checked whether the vertex
 really has valence 3 -- this has to be made sure in advance      */
{
 /* It might be that one of the edges leading to the new vertex now is
       an entry of firstedge[] */

 /* If (firstedge[e->start]==e->next) would take too much time, so just*/ 
 
    firstedge[e->start] = e;
    e->next = e->next->next; e->next->prev = e; 
    (degree[e->start])--;
    e = e->invers;

    firstedge[e->start] = e;
 /* Now delete on the ->prev side */
    e->prev = e->prev->prev; e->prev->next = e; 
    (degree[e->start])--;
    e = e->prev->invers;

    firstedge[e->start] = e;
 /* Again on the ->prev side: */
    e->prev = e->prev->prev; e->prev->next = e; 
    (degree[e->start])--;

    nv--;  
    ne -= 6;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movq -0x8(%rbp), %rdx
movq -0x8(%rbp), %rax
movslq (%rax), %rcx
leaq 0x10a46(%rip), %rax     # 0x3da00
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rax
movslq (%rax), %rcx
leaq 0x10c10(%rip), %rax     # 0x3dc00
movl (%rax,%rcx,4), %edx
addl $-0x1, %edx
leaq 0x10c03(%rip), %rax     # 0x3dc00
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdx
movq -0x8(%rbp), %rax
movslq (%rax), %rcx
leaq 0x109e2(%rip), %rax     # 0x3da00
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movslq (%rax), %rcx
leaq 0x10bac(%rip), %rax     # 0x3dc00
movl (%rax,%rcx,4), %edx
addl $-0x1, %edx
leaq 0x10b9f(%rip), %rax     # 0x3dc00
movl %edx, (%rax,%rcx,4)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
movq -0x8(%rbp), %rdx
movq -0x8(%rbp), %rax
movslq (%rax), %rcx
leaq 0x1097a(%rip), %rax     # 0x3da00
movq %rdx, (%rax,%rcx,8)
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rcx
movq -0x8(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x8(%rbp), %rcx
movq -0x8(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x8(%rbp), %rax
movslq (%rax), %rcx
leaq 0x10b44(%rip), %rax     # 0x3dc00
movl (%rax,%rcx,4), %edx
addl $-0x1, %edx
leaq 0x10b37(%rip), %rax     # 0x3dc00
movl %edx, (%rax,%rcx,4)
movl 0x22d54e(%rip), %eax    # 0x25a620
addl $-0x1, %eax
movl %eax, 0x22d545(%rip)    # 0x25a620
movl 0x22d543(%rip), %eax    # 0x25a624
subl $0x6, %eax
movl %eax, 0x22d53a(%rip)    # 0x25a624
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mishun[P]plantri/plantri.c
// Function: valid5edge
static int
valid5edge(EDGE *e)

/* e is an edge leaving a vertex of degree 5.  This function returns
   TRUE if e->end is not adjacent to either e->next->next->end or
   e->next->next->next->end, and FALSE otherwise. */
{
    register EDGE *e1,*ex;
    register int u,v;

    e1 = e->next->next;
    u = e1->end;
    v = e1->next->end;

    ex = e->invers;
    for (e1 = ex->next; e1 != ex; e1 = e1->next)
        if (e1->end == u || e1->end == v) return FALSE;

    return TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movl 0x4(%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
je 0x2d933
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
cmpl -0x24(%rbp), %eax
je 0x2d91a
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
cmpl -0x28(%rbp), %eax
jne 0x2d923
movl $0x0, -0x4(%rbp)
jmp 0x2d93a
jmp 0x2d925
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x2d8f8
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mishun[P]plantri/plantri.c
// Function: remove_vertex
static EDGE*
remove_vertex(int i)

/* removes vertex i from the graph and returns an edge with the
   new face on the left. Note that afterwards the vertices are
   in general no more numbered 0...nv-1, but maybe e.g. 0...nv
   with some number in the middle missing. 

*/
{
    EDGE *run, *end, *buffer;

    nv--;
    ne -= 2*degree[i];

    run=end=firstedge[i];

    do {
        buffer=run->invers;
        buffer->prev->next=buffer->next;
        buffer->next->prev=buffer->prev;
        (degree[buffer->start])--;
        firstedge[buffer->start]=buffer->next;
        run=run->next;
    } while (run!=end);

    missing_vertex = i;
    outside_face_size = degree[i];
    return buffer->next;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl 0x22cad3(%rip), %eax    # 0x25a620
addl $-0x1, %eax
movl %eax, 0x22caca(%rip)    # 0x25a620
movslq -0x4(%rbp), %rcx
leaq 0x1009f(%rip), %rax     # 0x3dc00
movl (%rax,%rcx,4), %ecx
shll %ecx
movl 0x22cab8(%rip), %eax    # 0x25a624
subl %ecx, %eax
movl %eax, 0x22cab0(%rip)    # 0x25a624
movslq -0x4(%rbp), %rcx
leaq 0xfe81(%rip), %rax      # 0x3da00
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rcx
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rcx
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movslq (%rax), %rcx
leaq 0x10033(%rip), %rax     # 0x3dc00
movl (%rax,%rcx,4), %edx
addl $-0x1, %edx
leaq 0x10026(%rip), %rax     # 0x3dc00
movl %edx, (%rax,%rcx,4)
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rdx
movq -0x20(%rbp), %rax
movslq (%rax), %rcx
leaq 0xfe0d(%rip), %rax      # 0x3da00
movq %rdx, (%rax,%rcx,8)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x2db8b
movl -0x4(%rbp), %eax
movl %eax, 0xe466(%rip)      # 0x3c080
movslq -0x4(%rbp), %rcx
leaq 0xffdb(%rip), %rax      # 0x3dc00
movl (%rax,%rcx,4), %eax
movl %eax, 0x27c232(%rip)    # 0x2a9e60
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/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 %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
cmpl $0x3, 0x22c9d1(%rip)    # 0x25a620
jne 0x2dc5d
movl $0x0, -0x4(%rbp)
jmp 0x2dd85
movl 0xe42d(%rip), %eax      # 0x3c090
addl $0x1, %eax
movl %eax, 0xe424(%rip)      # 0x3c090
cmpl $0x7530, %eax           # imm = 0x7530
jle 0x2dca9
movl $0x1, 0xe413(%rip)      # 0x3c090
movl $0x0, -0x2c(%rbp)
cmpl $0x40, -0x2c(%rbp)
jge 0x2dca7
movslq -0x2c(%rbp), %rcx
leaq 0x272fab(%rip), %rax    # 0x2a0c40
movl $0x0, (%rax,%rcx,4)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x2dc84
jmp 0x2dca9
movl 0xe3e1(%rip), %edx      # 0x3c090
movq -0x10(%rbp), %rax
movslq (%rax), %rcx
leaq 0x272f83(%rip), %rax    # 0x2a0c40
movl %edx, (%rax,%rcx,4)
movl 0xe3ca(%rip), %edx      # 0x3c090
movq -0x10(%rbp), %rax
movslq 0x4(%rax), %rcx
leaq 0x272f6b(%rip), %rax    # 0x2a0c40
movl %edx, (%rax,%rcx,4)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x10(%rbp), %rax
je 0x2dd7e
movl 0xe38c(%rip), %edx      # 0x3c090
movq -0x18(%rbp), %rax
movslq 0x4(%rax), %rcx
leaq 0x272f2d(%rip), %rax    # 0x2a0c40
movl %edx, (%rax,%rcx,4)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
je 0x2dd5f
movq -0x20(%rbp), %rax
movslq 0x4(%rax), %rcx
leaq 0x272f05(%rip), %rax    # 0x2a0c40
movl (%rax,%rcx,4), %eax
cmpl 0xe34c(%rip), %eax      # 0x3c090
jne 0x2dd4f
movl $0x0, -0x4(%rbp)
jmp 0x2dd85
jmp 0x2dd51
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x2dd22
jmp 0x2dd61
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x28(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x2dcf0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mishun[P]plantri/plantri.c
// Function: insert_vertex
static void
insert_vertex(int i)

/* inserts the previously removed vertex */
{

    EDGE *run, *end, *buffer;

    nv++;
    ne += 2*degree[i];

    run=end=firstedge[i];

    do {
        buffer=run->invers;
        buffer->prev->next=buffer;
        buffer->next->prev=buffer;
        (degree[buffer->start])++;
        run=run->next;
   } while (run!=end);

   missing_vertex = -1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl 0x22c883(%rip), %eax    # 0x25a620
addl $0x1, %eax
movl %eax, 0x22c87a(%rip)    # 0x25a620
movslq -0x4(%rbp), %rcx
leaq 0xfe4f(%rip), %rax      # 0x3dc00
movl (%rax,%rcx,4), %eax
shll %eax
addl 0x22c868(%rip), %eax    # 0x25a624
movl %eax, 0x22c862(%rip)    # 0x25a624
movslq -0x4(%rbp), %rcx
leaq 0xfc33(%rip), %rax      # 0x3da00
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rcx
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rcx, 0x10(%rax)
movq -0x20(%rbp), %rax
movslq (%rax), %rcx
leaq 0xfded(%rip), %rax      # 0x3dc00
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
leaq 0xfde0(%rip), %rax      # 0x3dc00
movl %edx, (%rax,%rcx,4)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x2ddd9
movl $0xffffffff, 0xe23d(%rip) # imm = 0xFFFFFFFF
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mishun[P]plantri/plantri.c
// Function: make_am
static void
make_am(void)

/* Make the adjacency matrix of the graph */
{
    int i;
    EDGE *e,*ex;
    long ami;

    for (i = 0; i < nv; ++i)
    {
        ami = 0;
        e = ex = firstedge[i];
        do
        {
            ami |= BIT(e->end);
            e = e->next;
        } while (e != ex);
        am[i] = ami;
    }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
cmpl 0x22c7bc(%rip), %eax    # 0x25a620
jge 0x2ded2
movq $0x0, -0x20(%rbp)
movslq -0x4(%rbp), %rcx
leaq 0xfb87(%rip), %rax      # 0x3da00
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, %ecx
movl $0x1, %eax
shlq %cl, %rax
orq -0x20(%rbp), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x2de85
movq -0x20(%rbp), %rdx
movslq -0x4(%rbp), %rcx
leaq 0x498dbd(%rip), %rax    # 0x4c6c80
movq %rdx, (%rax,%rcx,8)
movl -0x4(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x4(%rbp)
jmp 0x2de5b
popq %rbp
retq
nopw %cs:(%rax,%rax)