LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O3/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 0xe91d(%rip), %eax      # 0x26090
leal 0x1(%rax), %ecx
movl %ecx, 0xe914(%rip)      # 0x26090
cmpl $0x7530, %eax           # imm = 0x7530
jl 0x177a5
movl $0x1, 0xe903(%rip)      # 0x26090
leaq 0x27349c(%rip), %rdi    # 0x28ac30
movl $0x100, %edx            # imm = 0x100
xorl %esi, %esi
callq 0x1030
movl $0x1, %ecx
movq 0x20(%r14), %r8
movq 0x20(%rbx), %rsi
movq 0x18(%r8), %rax
movq 0x18(%rax), %rdi
movslq 0x4(%rdi), %r9
leaq 0x10430(%rip), %rax     # 0x27bf0
cmpl $0x5, (%rax,%r9,4)
leaq 0x273464(%rip), %rdx    # 0x28ac30
jne 0x177d2
movl %ecx, (%rdx,%r9,4)
movq 0x18(%rdi), %rdi
movslq 0x4(%rdi), %r9
cmpl $0x5, (%rax,%r9,4)
jne 0x177e5
movl %ecx, (%rdx,%r9,4)
movq 0x10(%r8), %r8
movq 0x10(%r8), %r8
cmpq %r8, %rdi
je 0x17807
movq 0x18(%rdi), %rdi
movslq 0x4(%rdi), %r9
cmpl $0x5, (%rax,%r9,4)
jne 0x177ed
movl %ecx, (%rdx,%r9,4)
jmp 0x177ed
movq 0x18(%rsi), %rax
movq 0x18(%rax), %rdi
movslq 0x4(%rdi), %r8
movl $0x1, %eax
cmpl %ecx, (%rdx,%r8,4)
je 0x1784b
movq 0x18(%rdi), %rdi
movslq 0x4(%rdi), %r8
cmpl %ecx, (%rdx,%r8,4)
je 0x1784b
movq 0x10(%rsi), %rsi
movq 0x10(%rsi), %rsi
cmpq %rsi, %rdi
je 0x17849
movq 0x18(%rdi), %rdi
movslq 0x4(%rdi), %r8
cmpl %ecx, (%rdx,%r8,4)
jne 0x17834
jmp 0x1784b
xorl %eax, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x17a92
movslq (%rbx), %r14
testq %r14, %r14
jle 0x17a80
xorl %r12d, %r12d
leaq 0x5f0(%rsp), %rbx
leaq 0xbc0(%rsp), %r15
movq 0x20(%rsp,%r12,8), %r13
movq %r13, %rdi
callq 0x16b44
movl $0x0, 0xc(%rsp)
movq %r13, %rdi
movq %rbx, %rsi
leaq 0xc(%rsp), %rdx
callq 0x17c9d
movl 0xc(%rsp), %ebp
movq %r13, %rdi
movq %rbx, %rsi
movl %ebp, %edx
movq %r15, %rcx
leaq 0x10(%rsp), %r8
callq 0x17e14
movl 0x10(%rsp), %esi
testl %esi, %esi
jle 0x17a70
movq %r15, %rdi
leaq 0x18(%rsp), %rdx
leaq 0x14(%rsp), %rcx
callq 0x16f77
testl %eax, %eax
je 0x17a70
movl 0x18(%rsp), %edi
movl 0x14(%rsp), %esi
movq %rbx, %rdx
movl %ebp, %ecx
callq 0x18023
movq %r13, %rdi
callq 0x175ce
incq %r12
cmpq %r12, %r14
jne 0x17a02
addq $0x1768, %rsp           # imm = 0x1768
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mishun[P]plantri/plantri.c
// Function: 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 0x17a92
cmpb $0x1, 0xe14b(%rip)      # 0x261a8
jne 0x1806b
movl %r15d, %edi
movl %ebp, %esi
callq 0x124c3
jmp 0x1807a
movl %r15d, %edi
movl %ebp, %esi
movl $0x3, %edx
callq 0x761c
movslq 0x10(%rsp), %r13
testq %r13, %r13
jle 0x18117
xorl %ebx, %ebx
leaq 0x5f0(%rsp), %r12
movq 0x20(%rsp,%rbx,8), %rbp
movq %rbp, %rdi
callq 0x16b44
movl 0xc(%rsp), %eax
movl %eax, 0x8(%rsp)
movq %rbp, %rdi
movq %r14, %rsi
leaq 0x8(%rsp), %rdx
callq 0x17c9d
movl 0x8(%rsp), %r15d
movq %rbp, %rdi
movq %r14, %rsi
movl %r15d, %edx
movq %r12, %rcx
leaq 0x14(%rsp), %r8
callq 0x17e14
movl 0x14(%rsp), %esi
testl %esi, %esi
jle 0x18103
movq %r12, %rdi
leaq 0x1c(%rsp), %rdx
leaq 0x18(%rsp), %rcx
callq 0x16f77
testl %eax, %eax
je 0x18103
movl 0x1c(%rsp), %edi
movl 0x18(%rsp), %esi
movq %r14, %rdx
movl %r15d, %ecx
callq 0x18023
movq %rbp, %rdi
callq 0x175ce
incq %rbx
cmpq %rbx, %r13
jne 0x18092
addq $0x1198, %rsp           # imm = 0x1198
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
// File: /workspace/github_c_makefile_star2_O3/mishun[P]plantri/plantri.c
// Function: 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 0xfab9(%rip), %rcx      # 0x27bf0
xorl %ebx, %ebx
cmpl $0x5, (%rcx,%rax,4)
jne 0x181f3
movq %rdi, %r14
movl 0xdf40(%rip), %ecx      # 0x2608c
leal 0x2(%rcx), %eax
movl %eax, 0xdf37(%rip)      # 0x2608c
cmpl $0x752f, %ecx           # imm = 0x752F
jl 0x1818b
movl $0x2, 0xdf25(%rip)      # 0x2608c
movl $0x30, %eax
leaq 0x22c4ad(%rip), %rcx    # 0x244620
movl $0x0, (%rax,%rcx)
addq $0x40, %rax
cmpq $0x46630, %rax          # imm = 0x46630
jne 0x18173
movl $0x2, %eax
testl %edx, %edx
jle 0x181a5
movl %edx, %ecx
incq %rcx
movq -0x10(%rsi,%rcx,8), %rdx
movl %eax, 0x30(%rdx)
decq %rcx
cmpq $0x1, %rcx
ja 0x18194
movq 0x18(%r14), %rdi
movq 0x28(%rdi), %rcx
cmpl %eax, 0x30(%rcx)
jne 0x181f3
movq 0x10(%r14), %rsi
movq 0x28(%rsi), %rcx
cmpl %eax, 0x30(%rcx)
jne 0x181f3
movq 0x20(%r14), %rcx
movq 0x18(%rcx), %rdx
movq 0x28(%rdx), %rdx
cmpl %eax, 0x30(%rdx)
jne 0x181f3
movq 0x10(%rcx), %rcx
movq 0x28(%rcx), %rcx
cmpl %eax, 0x30(%rcx)
jne 0x181f3
callq 0x17763
testl %eax, %eax
je 0x181f3
movq %r14, %rdi
callq 0x181fd
movl %eax, %ebx
xorl $0x1, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/mishun[P]plantri/plantri.c
// Function: extend_four
static void
extend_four(EDGE *ref)

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

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

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

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

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

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

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

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

    nv++;
    ne+=6;
}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
movslq 0x22af13(%rip), %rax    # 0x244610
leaq (%rax,%rax,2), %rdx
shlq $0x7, %rdx
leaq 0x22af14(%rip), %r8     # 0x244620
leaq (%r8,%rdx), %rcx
movq 0x18(%rdi), %rsi
movq 0x20(%rsi), %r10
movq 0x18(%r10), %r11
leaq 0xe4cd(%rip), %r9       # 0x27bf0
movl $0x4, (%r9,%rax,4)
leaq 0xe2be(%rip), %rbx      # 0x279f0
movq %rcx, (%rbx,%rax,8)
leaq 0x40(%rdx,%r8), %rsi
movslq (%r11), %r14
movl %r14d, (%rsi)
movl %r14d, -0x3c(%rsi)
incl (%r9,%r14,4)
movq %rsi, 0x18(%r10)
movq %rsi, 0x10(%r11)
movq %r10, 0x10(%rsi)
movq %r11, 0x18(%rsi)
movq 0x20(%r10), %r10
movq 0x10(%rdi), %r11
leaq 0xc0(%rdx,%r8), %r14
movslq (%r10), %r15
movl %r15d, (%r14)
movl %r15d, -0x3c(%r14)
movq %r14, (%rbx,%r15,8)
movq %r14, 0x18(%r11)
movq %r14, 0x10(%r10)
movq %r11, 0x10(%r14)
movq %r10, 0x18(%r14)
movq 0x20(%r11), %r10
movq 0x10(%r10), %r11
leaq 0x100(%rdx,%r8), %rbx
leaq 0x140(%rdx,%r8), %rdx
movslq (%r11), %r8
movl %r8d, (%rdx)
movl %r8d, -0x3c(%rdx)
incl (%r9,%r8,4)
movq %rdx, 0x18(%r11)
movq %rdx, 0x10(%r10)
movq %r11, 0x10(%rdx)
movq %r10, 0x18(%rdx)
movq %rdi, -0x30(%rsi)
movq %rdi, -0x28(%rdx)
movq %rcx, 0x18(%rdi)
movq %rbx, 0x10(%rdi)
movq 0x20(%rdi), %rcx
movl %eax, 0x4(%rcx)
movl %eax, (%rdi)
incl %eax
movl %eax, 0x22ae32(%rip)    # 0x244610
addl $0x6, 0x22ae2f(%rip)    # 0x244614
popq %rbx
popq %r14
popq %r15
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xdd58(%rip), %rsi      # 0x279f0
movq %rax, (%rsi,%rdx,8)
leaq 0xdf4d(%rip), %rax      # 0x27bf0
decl (%rax,%rdx,4)
movq 0x20(%rcx), %rcx
movq 0x10(%rcx), %rdx
movq 0x10(%rdx), %rdx
movq %rdi, 0x18(%rdx)
movq %rdi, 0x10(%rcx)
movq %rcx, 0x18(%rdi)
movq %rdx, 0x10(%rdi)
movslq (%rcx), %r8
movq 0x20(%rdi), %r9
movl %r8d, 0x4(%r9)
movl %r8d, (%rdi)
movq %rcx, (%rsi,%r8,8)
movq 0x20(%rdx), %rcx
movq 0x10(%rcx), %rdx
movq 0x10(%rdx), %rdx
movq %rdx, 0x10(%rcx)
movq %rcx, 0x18(%rdx)
movslq (%rcx), %rdx
decl (%rax,%rdx,4)
decl 0x22a91c(%rip)          # 0x244610
movq %rcx, (%rsi,%rdx,8)
addl $-0x6, 0x22a915(%rip)   # 0x244614
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xdd8c(%rip), %rcx      # 0x27bf0
xorl %eax, %eax
cmpl $0x4, (%rcx,%rdx,4)
jne 0x19ebb
leaq 0xdb7d(%rip), %rax      # 0x279f0
movq (%rax,%rdx,8), %rdx
movq 0x10(%rdx), %rax
movslq 0x4(%rax), %rax
cmpl $0x5, (%rcx,%rax,4)
jl 0x19e98
movq 0x18(%rdx), %rax
movslq 0x4(%rax), %rsi
movl $0x1, %eax
cmpl $0x4, (%rcx,%rsi,4)
jg 0x19ebb
movslq 0x4(%rdx), %rax
cmpl $0x5, (%rcx,%rax,4)
jl 0x19eb9
movq 0x18(%rdx), %rax
movq 0x18(%rax), %rax
movslq 0x4(%rax), %rdx
movl $0x1, %eax
cmpl $0x4, (%rcx,%rdx,4)
jg 0x19ebb
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x22a74d(%rip), %rcx    # 0x244610
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
testq %rcx, %rcx
jle 0x19f35
leaq 0xdb1c(%rip), %rsi      # 0x279f0
leaq 0xdd15(%rip), %rdi      # 0x27bf0
xorl %edx, %edx
movq %rdi, %r8
cmpl $0x4, (%r8)
jne 0x19f25
movq (%rsi), %r9
movq 0x10(%r9), %r10
movslq 0x4(%r10), %r10
cmpl $0x5, (%rdi,%r10,4)
jl 0x19f07
movq 0x18(%r9), %r10
movslq 0x4(%r10), %r10
cmpl $0x4, (%rdi,%r10,4)
jg 0x19f36
movslq 0x4(%r9), %r10
cmpl $0x5, (%rdi,%r10,4)
jl 0x19f25
movq 0x18(%r9), %r9
movq 0x18(%r9), %r9
movslq 0x4(%r9), %r9
cmpl $0x4, (%rdi,%r9,4)
jg 0x19f36
incq %rdx
addq $0x8, %rsi
addq $0x4, %r8
cmpq %rdx, %rcx
jne 0x19ee0
retq
movl %edx, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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)
movslq (%rcx), %rcx
movq 0x20(%rax), %rsi
movl %ecx, 0x4(%rsi)
movl %ecx, (%rax)
leaq 0xda78(%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 0xd851(%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)
movslq (%rcx), %rsi
movq 0x20(%rdi), %r9
movl %esi, 0x4(%r9)
movl %esi, (%rdi)
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 0x22a411(%rip)          # 0x244610
movq %rcx, (%r8,%rax,8)
addl $-0x6, 0x22a40a(%rip)   # 0x244614
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xd67a(%rip), %rsi      # 0x27bf0
addl $-0x2, (%rsi,%rdx,4)
leaq 0xd46f(%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, 0x22a04a(%rip)   # 0x244610
addl $-0x12, 0x22a047(%rip)  # 0x244614
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xd618(%rip), %rdx      # 0x27bf0
xorl %eax, %eax
cmpl $0x4, (%rdx,%rcx,4)
jne 0x1a5fc
movq 0x10(%rdi), %rcx
movslq 0x4(%rcx), %rcx
cmpl $0x4, (%rdx,%rcx,4)
je 0x1a5fc
movq 0x18(%rdi), %rcx
movslq 0x4(%rcx), %rsi
cmpl $0x4, (%rdx,%rsi,4)
jne 0x1a5fd
retq
movq 0x18(%rcx), %rcx
movslq 0x4(%rcx), %rcx
cmpl $0x4, (%rdx,%rcx,4)
jne 0x1a611
movl $0x1, %eax
retq
movq 0x20(%rdi), %rsi
movq 0x10(%rsi), %rdx
movq 0x18(%rsi), %rsi
movq 0x18(%rsi), %rsi
cmpq %rdx, %rsi
je 0x1a60b
cmpl %ecx, 0x4(%rsi)
jne 0x1a61d
jmp 0x1a5fc
// File: /workspace/github_c_makefile_star2_O3/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 0x229fdc(%rip), %rax    # 0x244610
leal (,%rax,8), %ecx
movslq %ecx, %r8
shlq $0x6, %r8
leaq 0x229fd7(%rip), %r9     # 0x244620
leaq (%r8,%r9), %rsi
addq $0x180, %rsi            # imm = 0x180
leaq 0x200(%r8,%r9), %rcx
leaq 0x240(%r8,%r9), %rdx
leaq 0xd385(%rip), %r10      # 0x279f0
movq %rdx, (%r10,%rax,8)
movslq (%rdi), %r10
movq -0x60(%rcx), %r11
movl %r10d, 0x4(%r11)
movl %r10d, -0x80(%rcx)
movq 0x18(%rdi), %r11
movq %rsi, 0x10(%r11)
movq %r11, -0x68(%rcx)
movq %rdi, -0x70(%rcx)
movq %rsi, 0x18(%rdi)
leaq 0xd557(%rip), %rsi      # 0x27bf0
incl (%rsi,%r10,4)
addq %r9, %r8
addq $0x1c0, %r8             # imm = 0x1C0
movq 0x20(%rdi), %rdi
movq 0x10(%rdi), %rdi
movslq (%rdi), %r9
movq -0x60(%rdx), %r10
movl %r9d, 0x4(%r10)
movl %r9d, -0x80(%rdx)
movq 0x18(%rdi), %r10
movq %r8, 0x10(%r10)
movq %r10, -0x68(%rdx)
movq %rdi, -0x70(%rdx)
movq %r8, 0x18(%rdi)
incl (%rsi,%r9,4)
movq 0x20(%rdi), %rdi
movq 0x10(%rdi), %rdi
movslq (%rdi), %r8
movq -0x20(%rdx), %r9
movl %r8d, 0x4(%r9)
movl %r8d, -0x40(%rdx)
movq 0x18(%rdi), %r9
movq %rcx, 0x10(%r9)
movq %r9, -0x28(%rdx)
movq %rdi, -0x30(%rdx)
movq %rcx, 0x18(%rdi)
incl (%rsi,%r8,4)
addl $0x6, 0x229f08(%rip)    # 0x244614
movl $0x3, (%rsi,%rax,4)
incl %eax
movl %eax, 0x229ef5(%rip)    # 0x244610
retq
// File: /workspace/github_c_makefile_star2_O3/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, 0x229429(%rip)    # 0x244610
je 0x1b274
movq %rdi, %r14
movl 0xae9a(%rip), %ecx      # 0x26090
leal 0x1(%rcx), %eax
movl %eax, 0xae91(%rip)      # 0x26090
cmpl $0x7530, %ecx           # imm = 0x7530
jl 0x1b229
movl $0x1, 0xae7f(%rip)      # 0x26090
leaq 0x26fa18(%rip), %rdi    # 0x28ac30
movl $0x100, %edx            # imm = 0x100
xorl %esi, %esi
callq 0x1030
movl $0x1, %eax
movslq (%r14), %rdx
leaq 0x26f9fd(%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 0x1b26f
movslq 0x4(%rsi), %rdi
movl %eax, (%rcx,%rdi,4)
movq %rsi, %rdi
movq 0x18(%rdi), %rdi
cmpq %rdx, %rdi
je 0x1b269
movslq 0x4(%rdi), %r8
cmpl %eax, (%rcx,%r8,4)
jne 0x1b254
jmp 0x1b274
movq 0x20(%rsi), %rdx
jmp 0x1b241
movl $0x1, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xa746(%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 0xa527(%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, 0x227102(%rip)   # 0x244610
movq %rax, (%rcx,%rdx,8)
addl $-0xc, 0x2270fb(%rip)   # 0x244614
retq
// File: /workspace/github_c_makefile_star2_O3/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:
testl %esi, %esi
jle 0x1d9ec
pushq %r14
pushq %rbx
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 0x1d95c
cmpq %r9, 0x8(%rdi,%r10)
je 0x1d95c
cmpq %r9, 0x10(%rdi,%r10)
je 0x1d95c
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 0x1d92a
cmpl $0x2, %eax
jl 0x1d9e7
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 0x1d9e7
cmpl %edi, 0x4(%r10)
jne 0x1d989
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
popq %rbx
popq %r14
jmp 0x1d9ee
xorl %eax, %eax
movl %eax, (%r8)
retq
// File: /workspace/github_c_makefile_star2_O3/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 0xa0bf(%rip), %rcx      # 0x27bf0
xorl %eax, %eax
cmpl $0x4, (%rcx,%rdx,4)
jne 0x1dbaa
movslq 0x4(%rdi), %rdx
cmpl $0x4, (%rcx,%rdx,4)
je 0x1dbaa
movq 0x18(%rdi), %rdx
movslq 0x4(%rdx), %rsi
cmpl $0x4, (%rcx,%rsi,4)
je 0x1dbaa
movq 0x10(%rdi), %rsi
movslq 0x4(%rsi), %rsi
cmpl $0x4, (%rcx,%rsi,4)
je 0x1dbaa
movq 0x18(%rdx), %rdx
movslq 0x4(%rdx), %rsi
cmpl $0x4, (%rcx,%rsi,4)
jne 0x1dbaa
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 0x1dbaa
movq 0x20(%rdi), %rax
movq 0x10(%rax), %rcx
movq 0x18(%rax), %rsi
movq 0x18(%rsi), %rsi
cmpq %rcx, %rsi
je 0x1dba2
cmpl %edx, 0x4(%rsi)
jne 0x1db94
xorl %eax, %eax
cmpq %rcx, %rsi
sete %al
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x226a5e(%rip), %rcx    # 0x244610
testq %rcx, %rcx
jle 0x1dc8d
leaq 0xa02e(%rip), %rdx      # 0x27bf0
leaq 0x9e27(%rip), %rsi      # 0x279f0
xorl %edi, %edi
cmpl $0x4, (%rdx,%rdi,4)
jne 0x1dc81
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 0x1dc81
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 0x1dc8f
movl 0x4(%rax), %r9d
movq (%rsi,%r10,8), %r11
movq %r11, %r10
cmpl %r9d, 0x4(%r10)
je 0x1dc81
movq 0x18(%r10), %r10
cmpq %r11, %r10
jne 0x1dc6c
cmpl %r9d, 0x4(%r10)
jne 0x1dc8f
incq %rdi
cmpq %rcx, %rdi
jne 0x1dbcb
xorl %eax, %eax
retq
// File: /workspace/github_c_makefile_star2_O3/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 0x91af(%rip), %rcx      # 0x27bf0
movl $0x1, %ebx
cmpl $0x3, (%rcx,%rax,4)
je 0x1eaf3
movq %rdi, %r14
movl 0x7637(%rip), %ecx      # 0x26090
leal 0x1(%rcx), %eax
movl %eax, 0x762e(%rip)      # 0x26090
cmpl $0x7530, %ecx           # imm = 0x7530
jl 0x1ea8c
movl $0x1, 0x761c(%rip)      # 0x26090
leaq 0x26c1b5(%rip), %rdi    # 0x28ac30
movl $0x100, %edx            # imm = 0x100
xorl %esi, %esi
callq 0x1030
movl $0x1, %eax
movq 0x20(%r14), %rcx
movq 0x10(%rcx), %rdx
movq 0x18(%rcx), %rcx
movq 0x18(%rcx), %rsi
leaq 0x26c18d(%rip), %rcx    # 0x28ac30
movslq 0x4(%rsi), %rdi
movl %eax, (%rcx,%rdi,4)
movq 0x18(%rsi), %rsi
cmpq %rdx, %rsi
jne 0x1eaa3
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 0x1eaf1
movq 0x18(%r8), %r8
cmpq %rdi, %r8
jne 0x1ead3
movq 0x18(%rsi), %rsi
cmpq %rdx, %rsi
jne 0x1eacb
jmp 0x1eaf3
xorl %ebx, %ebx
movl %ebx, %eax
addq $0x8, %rsp
popq %rbx
popq %r14
retq
// File: /workspace/github_c_makefile_star2_O3/mishun[P]plantri/plantri.c
// Function: update_nft_four
static void
update_nft_four(triangle nft[], int numnft, EDGE *ref,
                triangle newnft[], int *newnumnft)

/* Make new list of non-facial triangles after a four-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 a shortcut if there is one (only possible if there are >= 2 others) */
    if (k >= 2)
    {
        w = ref->next->end;
        elast = ref->invers->next->invers;
        for (e = elast->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;
            ++k;
        }
    }
    *newnumnft = k;
}

// Assembly:
testl %esi, %esi
jle 0x1f849
pushq %r14
pushq %rbx
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 0x1f7e5
cmpq %r9, 0x8(%rdi,%r10)
je 0x1f7e5
cmpq %r9, 0x10(%rdi,%r10)
je 0x1f7e5
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 0x1f7b3
cmpl $0x2, %eax
jl 0x1f844
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
cmpq %r9, %r10
je 0x1f844
cmpl %edi, 0x4(%r10)
jne 0x1f80e
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)
incl %eax
popq %rbx
popq %r14
jmp 0x1f84b
xorl %eax, %eax
movl %eax, (%r8)
retq
// File: /workspace/github_c_makefile_star2_O3/icysunlight[P]miniftpd/main.c
// Function: hash_fun
unsigned int hash_fun(void* key,int hashtable_size)
{
    unsigned int hash = 0;
    char* str = key;
    while(*str)
    {
        hash += (hash << 5) + (*str++);
    }

    return ( hash & 0x7fffffff ) % hashtable_size;
}

// Assembly:
movb (%rdi), %cl
testb %cl, %cl
je 0x3ca2
incq %rdi
xorl %eax, %eax
movsbl %cl, %ecx
movl %eax, %edx
shll $0x5, %edx
addl %edx, %eax
addl %ecx, %eax
movb (%rdi), %cl
incq %rdi
testb %cl, %cl
jne 0x3c86
andl $0x7fffffff, %eax       # imm = 0x7FFFFFFF
jmp 0x3ca4
xorl %eax, %eax
xorl %edx, %edx
divl %esi
movl %edx, %eax
retq
nop
// File: /workspace/github_c_makefile_star2_O3/icysunlight[P]miniftpd/sysutil.c
// Function: tcp_srv
int tcp_srv(const char* host,const unsigned short port)
{
    int fd = socket(AF_INET,SOCK_STREAM,0);
    if (-1 == fd)
        ERR_EXIT("socket error");

    int on = 1;
    if (-1 == setsockopt(fd,SOL_SOCKET,SO_REUSEADDR,(const char*)&on,sizeof(on)))
        ERR_EXIT("setsockopt error");

    struct sockaddr_in srvaddr;
    memset(&srvaddr,0,sizeof(srvaddr));
    srvaddr.sin_family = AF_INET;
    srvaddr.sin_port = htons(port);
    if (NULL != host)
    {
        if (0 == inet_aton(host,&srvaddr.sin_addr))
            ERR_EXIT("inet_aton");
    }
    else
        srvaddr.sin_addr.s_addr = htonl(INADDR_ANY);

    if (-1 == bind(fd,(struct sockaddr*)&srvaddr,sizeof(srvaddr)))
        ERR_EXIT("bind error");

    if (-1 == listen(fd,10))
        ERR_EXIT("listen error");

    return fd;

}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %esi, %ebp
movq %rdi, %r14
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x3550
cmpl $-0x1, %eax
je 0x3e3f
movl %eax, %ebx
leaq 0x1c(%rsp), %rcx
movl $0x1, (%rcx)
movl %eax, %edi
movl $0x1, %esi
movl $0x2, %edx
movl $0x4, %r8d
callq 0x30d0
cmpl $-0x1, %eax
je 0x3e44
movl $0x0, 0x18(%rsp)
movq $0x0, 0x10(%rsp)
movw $0x2, 0xc(%rsp)
rolw $0x8, %bp
movw %bp, 0xe(%rsp)
testq %r14, %r14
je 0x3e0d
leaq 0x10(%rsp), %rsi
movq %r14, %rdi
callq 0x3380
testl %eax, %eax
je 0x3e53
leaq 0xc(%rsp), %rsi
movl %ebx, %edi
movl $0x10, %edx
callq 0x3410
cmpl $-0x1, %eax
je 0x3e49
movl %ebx, %edi
movl $0xa, %esi
callq 0x33c0
cmpl $-0x1, %eax
je 0x3e4e
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x3638
callq 0x3623
callq 0x360e
callq 0x35f9
callq 0x35e4
// File: /workspace/github_c_makefile_star2_O3/icysunlight[P]miniftpd/sysutil.c
// Function: tcp_clnt
int tcp_clnt(const char* host,const unsigned short port)
{
    int fd = socket(PF_INET,SOCK_STREAM,0);
    if (-1 == fd)
        ERR_EXIT("socket error");

    int on = 1;
    if (-1 == setsockopt(fd,SOL_SOCKET,SO_REUSEADDR,(const char*)&on,sizeof(on)))
        ERR_EXIT("setsockopt error");
    
    if ( port > 0 )
    {
        struct sockaddr_in srvaddr;
        memset(&srvaddr,0,sizeof(srvaddr));
        srvaddr.sin_family = AF_INET;
        srvaddr.sin_port = htons(port);
        if (0 == inet_aton(host,&srvaddr.sin_addr))
            ERR_EXIT("inet_aton");
        if (-1 == bind(fd,(struct sockaddr*)&srvaddr,sizeof(srvaddr)))
            ERR_EXIT("bind error");
    }

    return fd;
}

// Assembly:
pushq %rbp
pushq %r14
pushq %rbx
subq $0x20, %rsp
movl %esi, %ebp
movq %rdi, %r14
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x3550
cmpl $-0x1, %eax
je 0x3ef7
movl %eax, %ebx
leaq 0xc(%rsp), %rcx
movl $0x1, (%rcx)
movl %eax, %edi
movl $0x1, %esi
movl $0x2, %edx
movl $0x4, %r8d
callq 0x30d0
cmpl $-0x1, %eax
je 0x3efc
testw %bp, %bp
je 0x3eec
leaq 0x14(%rsp), %rsi
movl $0x0, 0x8(%rsi)
movq $0x0, (%rsi)
movw $0x2, -0x4(%rsi)
rolw $0x8, %bp
movw %bp, -0x2(%rsi)
movq %r14, %rdi
callq 0x3380
testl %eax, %eax
je 0x3f01
leaq 0x10(%rsp), %rsi
movl %ebx, %edi
movl $0x10, %edx
callq 0x3410
cmpl $-0x1, %eax
je 0x3f06
movl %ebx, %eax
addq $0x20, %rsp
popq %rbx
popq %r14
popq %rbp
retq
callq 0x368c
callq 0x3677
callq 0x3662
callq 0x364d
// File: /workspace/github_c_makefile_star2_O3/icysunlight[P]miniftpd/sysutil.c
// Function: getlocalip
int getlocalip(char *ip)
{
    int sockfd; 
    if(-1 == (sockfd = socket(PF_INET, SOCK_STREAM, 0)))
    {
        perror( "socket" );
        return -1;
    }
    struct ifreq req;
    struct sockaddr_in *host;
    bzero(&req, sizeof(struct ifreq));
    strcpy(req.ifr_name, "eth0"); 
    ioctl(sockfd, SIOCGIFADDR, &req);
    host = (struct sockaddr_in*)&req.ifr_addr;
    strcpy(ip, inet_ntoa(host->sin_addr));
    close(sockfd);
    return 1;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x28, %rsp
movq %rdi, %r14
movl $0x1, %ebx
movl $0x2, %edi
movl $0x1, %esi
xorl %edx, %edx
callq 0x3550
cmpl $-0x1, %eax
je 0x3f92
movl %eax, %ebp
xorps %xmm0, %xmm0
movq %rsp, %r15
movups %xmm0, 0x15(%r15)
movups %xmm0, 0x5(%r15)
movl $0x0, 0x24(%r15)
movl $0x30687465, (%r15)     # imm = 0x30687465
movb $0x0, 0x4(%r15)
movl $0x8915, %esi           # imm = 0x8915
movl %eax, %edi
movq %r15, %rdx
xorl %eax, %eax
callq 0x3230
movl 0x14(%r15), %edi
callq 0x3120
movq %r14, %rdi
movq %rax, %rsi
callq 0x3090
movl %ebp, %edi
callq 0x3260
movl %ebx, %eax
addq $0x28, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
leaq 0x418c(%rip), %rdi      # 0x8125
callq 0x3470
movl $0xffffffff, %ebx       # imm = 0xFFFFFFFF
jmp 0x3f85
// File: /workspace/github_c_makefile_star2_O3/icysunlight[P]miniftpd/sysutil.c
// Function: activate_nonblock
void activate_nonblock(int fd)
{
    int ret;
    int flags = fcntl(fd, F_GETFL);
    if (flags == -1)
        ERR_EXIT("fcntl");

    flags |= O_NONBLOCK;
    ret = fcntl(fd, F_SETFL, flags);
    if (ret == -1)
        ERR_EXIT("fcntl");
}

// Assembly:
pushq %rbx
movl %edi, %ebx
movl $0x3, %esi
xorl %eax, %eax
callq 0x30f0
cmpl $-0x1, %eax
je 0x3fd5
orl $0x800, %eax            # imm = 0x800
movl %ebx, %edi
movl $0x4, %esi
movl %eax, %edx
xorl %eax, %eax
callq 0x30f0
cmpl $-0x1, %eax
je 0x3fda
popq %rbx
retq
callq 0x36b6
callq 0x36a1
// File: /workspace/github_c_makefile_star2_O3/icysunlight[P]miniftpd/sysutil.c
// Function: read_timeout
int read_timeout(int fd, unsigned int wait_seconds)
{
    int ret = 0;
    if (wait_seconds > 0)
    {
        fd_set read_fdset;
        struct timeval timeout;

        FD_ZERO(&read_fdset);
        FD_SET(fd, &read_fdset);

        timeout.tv_sec = wait_seconds;
        timeout.tv_usec = 0;
        do
        {
            ret = select(fd + 1, &read_fdset, NULL, NULL, &timeout);
        } while (ret < 0 && errno == EINTR);

        if (ret == 0)
        {
            ret = -1;
            errno = ETIMEDOUT;
        }
        else if (ret == 1)
            ret = 0;
    }

    return ret;
}

// Assembly:
testl %esi, %esi
je 0x40b7
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
movl %edi, %ebx
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r14
movaps %xmm0, (%r14)
movaps %xmm0, 0x10(%r14)
movaps %xmm0, 0x20(%r14)
movaps %xmm0, 0x30(%r14)
movaps %xmm0, 0x40(%r14)
movaps %xmm0, 0x50(%r14)
leal 0x3f(%rbx), %eax
testl %edi, %edi
cmovnsl %edi, %eax
movl %eax, %edx
andl $-0x40, %edx
movl %edi, %ecx
subl %edx, %ecx
movl $0x1, %edx
shlq %cl, %rdx
movaps %xmm0, 0x60(%r14)
movaps %xmm0, 0x70(%r14)
sarl $0x6, %eax
cltq
orq %rdx, 0x10(%rsp,%rax,8)
movl %esi, %eax
movq %rsp, %r15
movq %rax, (%r15)
movq $0x0, 0x8(%r15)
incl %ebx
movl %ebx, %edi
movq %r14, %rsi
xorl %edx, %edx
xorl %ecx, %ecx
movq %r15, %r8
callq 0x3370
movl %eax, %ebp
testl %eax, %eax
jns 0x40ba
callq 0x3060
cmpl $0x4, (%rax)
je 0x4094
jmp 0x40bc
xorl %eax, %eax
retq
je 0x40d2
xorl %eax, %eax
cmpl $0x1, %ebp
cmovnel %ebp, %eax
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x3060
movl $0x6e, (%rax)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x40c4
// File: /workspace/github_c_makefile_star2_O3/icysunlight[P]miniftpd/sysutil.c
// Function: write_timeout
int write_timeout(int fd, unsigned int wait_seconds)
{
    int ret = 0;
    if (wait_seconds > 0)
    {
        fd_set write_fdset;
        struct timeval timeout;

        FD_ZERO(&write_fdset);
        FD_SET(fd, &write_fdset);

        timeout.tv_sec = wait_seconds;
        timeout.tv_usec = 0;
        do
        {
            ret = select(fd + 1, NULL, NULL, &write_fdset, &timeout);
        } while (ret < 0 && errno == EINTR);

        if (ret == 0)
        {
            ret = -1;
            errno = ETIMEDOUT;
        }
        else if (ret == 1)
            ret = 0;
    }

    return ret;
}

// Assembly:
testl %esi, %esi
je 0x4182
pushq %rbp
pushq %r15
pushq %r14
pushq %rbx
subq $0x98, %rsp
movl %edi, %ebx
xorps %xmm0, %xmm0
leaq 0x10(%rsp), %r14
movaps %xmm0, (%r14)
movaps %xmm0, 0x10(%r14)
movaps %xmm0, 0x20(%r14)
movaps %xmm0, 0x30(%r14)
movaps %xmm0, 0x40(%r14)
movaps %xmm0, 0x50(%r14)
leal 0x3f(%rbx), %eax
testl %edi, %edi
cmovnsl %edi, %eax
movl %eax, %edx
andl $-0x40, %edx
movl %edi, %ecx
subl %edx, %ecx
movl $0x1, %edx
shlq %cl, %rdx
movaps %xmm0, 0x60(%r14)
movaps %xmm0, 0x70(%r14)
sarl $0x6, %eax
cltq
orq %rdx, 0x10(%rsp,%rax,8)
movl %esi, %eax
movq %rsp, %r15
movq %rax, (%r15)
movq $0x0, 0x8(%r15)
incl %ebx
movl %ebx, %edi
xorl %esi, %esi
xorl %edx, %edx
movq %r14, %rcx
movq %r15, %r8
callq 0x3370
movl %eax, %ebp
testl %eax, %eax
jns 0x4185
callq 0x3060
cmpl $0x4, (%rax)
je 0x415f
jmp 0x4187
xorl %eax, %eax
retq
je 0x419d
xorl %eax, %eax
cmpl $0x1, %ebp
cmovnel %ebp, %eax
addq $0x98, %rsp
popq %rbx
popq %r14
popq %r15
popq %rbp
retq
callq 0x3060
movl $0x6e, (%rax)
movl $0xffffffff, %eax       # imm = 0xFFFFFFFF
jmp 0x418f