LLM4Binary/decompile-bench-makefile huggingface dataset:
// File: /workspace/github_c_makefile_star2_O0/mishun[P]plantri/plantri.c
// Function: write_edgecode
static void
write_edgecode(FILE *f, int doflip)   

/* Write in edge_code format.  Always write in next direction,
   and if doflip != 0 also write in prev direction. */
{
    int length, headerlength;
    unsigned char code[MAXN+MAXE+4]; 
    unsigned char mirrorcode[MAXN+MAXE+4];


      if ((ne/2)>UCHAR_MAX) 
	{ fprintf(stderr,
             ">E %s: Output routine write_edgecode not prepared for ",cmdname);
	  fprintf(stderr,"that many edges\n");
	  exit(1);
	}

    compute_edgecode(code,&length,&headerlength);

    if (fwrite(code,sizeof(unsigned char),length,f) != length)
    {
        fprintf(stderr,">E %s: fwrite() failed\n",cmdname);
        perror(">E ");
        exit(1);
    }
    if (doflip)
      { mirror_of_edgecode(mirrorcode, code, (code_edge!=NULL), length, headerlength);
        if (fwrite(mirrorcode,sizeof(unsigned char),length,f) != length)
	  {
	    fprintf(stderr,">E %s: fwrite() failed\n",cmdname);
	    perror(">E ");
	    exit(1);
	  }
      }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x390, %rsp            # imm = 0x390
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl 0x2500fc(%rip), %eax    # 0x25a624
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0xff, %eax
jle 0xa578
movq 0x31aba(%rip), %rax     # 0x3bff8
movq (%rax), %rdi
movq 0x31b78(%rip), %rdx     # 0x3c0c0
leaq 0x2ded9(%rip), %rsi     # 0x38428
movb $0x0, %al
callq 0x1060
movq 0x31a9b(%rip), %rax     # 0x3bff8
movq (%rax), %rdi
leaq 0x2def8(%rip), %rsi     # 0x3845f
movb $0x0, %al
callq 0x1060
movl $0x1, %edi
callq 0x10c0
leaq -0x1d0(%rbp), %rdi
leaq -0x10(%rbp), %rsi
leaq -0x14(%rbp), %rdx
callq 0xc010
leaq -0x1d0(%rbp), %rdi
movslq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rcx
movl $0x1, %esi
callq 0x10d0
movslq -0x10(%rbp), %rcx
cmpq %rcx, %rax
je 0xa5e3
movq 0x31a43(%rip), %rax     # 0x3bff8
movq (%rax), %rdi
movq 0x31b01(%rip), %rdx     # 0x3c0c0
leaq 0x2de4a(%rip), %rsi     # 0x38410
movb $0x0, %al
callq 0x1060
leaq 0x2ddd0(%rip), %rdi     # 0x383a4
callq 0x10a0
movl $0x1, %edi
callq 0x10c0
cmpl $0x0, -0xc(%rbp)
je 0xa670
leaq -0x390(%rbp), %rdi
leaq -0x1d0(%rbp), %rsi
cmpq $0x0, 0x250025(%rip)    # 0x25a628
setne %al
andb $0x1, %al
movzbl %al, %edx
movl -0x10(%rbp), %ecx
movl -0x14(%rbp), %r8d
callq 0xc390
leaq -0x390(%rbp), %rdi
movslq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rcx
movl $0x1, %esi
callq 0x10d0
movslq -0x10(%rbp), %rcx
cmpq %rcx, %rax
je 0xa66e
movq 0x319b8(%rip), %rax     # 0x3bff8
movq (%rax), %rdi
movq 0x31a76(%rip), %rdx     # 0x3c0c0
leaq 0x2ddbf(%rip), %rsi     # 0x38410
movb $0x0, %al
callq 0x1060
leaq 0x2dd45(%rip), %rdi     # 0x383a4
callq 0x10a0
movl $0x1, %edi
callq 0x10c0
jmp 0xa670
addq $0x390, %rsp            # imm = 0x390
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mishun[P]plantri/plantri.c
// Function: write_dual_edgecode
static void
write_dual_edgecode(FILE *f, int doflip)   

/* Write in edge_code format.  Always write in next direction,
   and if doflip != 0 also write in prev direction. */
{
    int length, headerlength;
    unsigned char code[MAXF+MAXE+4], mirrorcode[MAXF+MAXE+4];


      if ((ne/2)>UCHAR_MAX) 
	{ fprintf(stderr,
         ">E %s: Output routine write_dual_edgecode not prepared for ",cmdname);
	  fprintf(stderr,"that many edges\n");
	  exit(1);
	}

    compute_dual_edgecode(code,&length,&headerlength);
    if (fwrite(code,sizeof(unsigned char),length,f) != length)
    {
        fprintf(stderr,">E %s: fwrite() failed\n",cmdname);
        perror(">E ");
        exit(1);
    }
    if (doflip)
      { mirror_of_edgecode(mirrorcode, code, 0,length,headerlength);
        if (fwrite(mirrorcode,sizeof(unsigned char),length,f) != length)
	  {
	    fprintf(stderr,">E %s: fwrite() failed\n",cmdname);
	    perror(">E ");
	    exit(1);
	  }
      }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x410, %rsp            # imm = 0x410
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl 0x24ff8c(%rip), %eax    # 0x25a624
movl $0x2, %ecx
cltd
idivl %ecx
cmpl $0xff, %eax
jle 0xa6e8
movq 0x3194a(%rip), %rax     # 0x3bff8
movq (%rax), %rdi
movq 0x31a08(%rip), %rdx     # 0x3c0c0
leaq 0x2ddee(%rip), %rsi     # 0x384ad
movb $0x0, %al
callq 0x1060
movq 0x3192b(%rip), %rax     # 0x3bff8
movq (%rax), %rdi
leaq 0x2dd88(%rip), %rsi     # 0x3845f
movb $0x0, %al
callq 0x1060
movl $0x1, %edi
callq 0x10c0
leaq -0x210(%rbp), %rdi
leaq -0x10(%rbp), %rsi
leaq -0x14(%rbp), %rdx
callq 0xc760
leaq -0x210(%rbp), %rdi
movslq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rcx
movl $0x1, %esi
callq 0x10d0
movslq -0x10(%rbp), %rcx
cmpq %rcx, %rax
je 0xa753
movq 0x318d3(%rip), %rax     # 0x3bff8
movq (%rax), %rdi
movq 0x31991(%rip), %rdx     # 0x3c0c0
leaq 0x2dcda(%rip), %rsi     # 0x38410
movb $0x0, %al
callq 0x1060
leaq 0x2dc60(%rip), %rdi     # 0x383a4
callq 0x10a0
movl $0x1, %edi
callq 0x10c0
cmpl $0x0, -0xc(%rbp)
je 0xa7ce
leaq -0x410(%rbp), %rdi
leaq -0x210(%rbp), %rsi
movl -0x10(%rbp), %ecx
movl -0x14(%rbp), %r8d
xorl %edx, %edx
callq 0xc390
leaq -0x410(%rbp), %rdi
movslq -0x10(%rbp), %rdx
movq -0x8(%rbp), %rcx
movl $0x1, %esi
callq 0x10d0
movslq -0x10(%rbp), %rcx
cmpq %rcx, %rax
je 0xa7cc
movq 0x3185a(%rip), %rax     # 0x3bff8
movq (%rax), %rdi
movq 0x31918(%rip), %rdx     # 0x3c0c0
leaq 0x2dc61(%rip), %rsi     # 0x38410
movb $0x0, %al
callq 0x1060
leaq 0x2dbe7(%rip), %rdi     # 0x383a4
callq 0x10a0
movl $0x1, %edi
callq 0x10c0
jmp 0xa7ce
addq $0x410, %rsp            # imm = 0x410
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mishun[P]plantri/plantri.c
// Function: write_planar_code
static void
write_planar_code(FILE *f, int doflip)   

/* Write in planar_code format.  Always write in next direction,
   and if doflip != 0 also write in prev direction. */
{
    size_t length;
    unsigned char code[MAXN+MAXE+1];
    
    length=nv+ne+1;
    compute_code(code);
    if (fwrite(code,sizeof(unsigned char),length,f) != length)
    {
        fprintf(stderr,">E %s: fwrite() failed\n",cmdname);
        perror(">E ");
        exit(1);
    }
    if (doflip)
      { compute_code_mirror(code);
        if (fwrite(code,sizeof(unsigned char),length,f) != length)
	  {
	    fprintf(stderr,">E %s: fwrite() failed\n",cmdname);
	    perror(">E ");
	    exit(1);
	  }
      }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x1d0, %rsp            # imm = 0x1D0
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl 0x24fe28(%rip), %eax    # 0x25a620
addl 0x24fe26(%rip), %eax    # 0x25a624
addl $0x1, %eax
cltq
movq %rax, -0x18(%rbp)
leaq -0x1d0(%rbp), %rdi
callq 0xaa00
leaq -0x1d0(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rcx
movl $0x1, %esi
callq 0x10d0
cmpq -0x18(%rbp), %rax
je 0xa867
movq 0x317bf(%rip), %rax     # 0x3bff8
movq (%rax), %rdi
movq 0x3187d(%rip), %rdx     # 0x3c0c0
leaq 0x2dbc6(%rip), %rsi     # 0x38410
movb $0x0, %al
callq 0x1060
leaq 0x2db4c(%rip), %rdi     # 0x383a4
callq 0x10a0
movl $0x1, %edi
callq 0x10c0
cmpl $0x0, -0xc(%rbp)
je 0xa8cf
leaq -0x1d0(%rbp), %rdi
callq 0xad00
leaq -0x1d0(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rcx
movl $0x1, %esi
callq 0x10d0
cmpq -0x18(%rbp), %rax
je 0xa8cd
movq 0x31759(%rip), %rax     # 0x3bff8
movq (%rax), %rdi
movq 0x31817(%rip), %rdx     # 0x3c0c0
leaq 0x2db60(%rip), %rsi     # 0x38410
movb $0x0, %al
callq 0x1060
leaq 0x2dae6(%rip), %rdi     # 0x383a4
callq 0x10a0
movl $0x1, %edi
callq 0x10c0
jmp 0xa8cf
addq $0x1d0, %rsp            # imm = 0x1D0
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mishun[P]plantri/plantri.c
// Function: write_dual_planar_code
static void
write_dual_planar_code(FILE *f, int doflip)   

/* Write the dual in planar_code format.  Always write in next direction,
   and if doflip != 0 also write in prev direction. */
{
    size_t length;
    unsigned char code[MAXF+MAXE+1];
    
    length=3+ne+(ne/2)-nv;
    compute_dual_code(code);
    if (fwrite(code,sizeof(unsigned char),length,f) != length)
    {
        fprintf(stderr,">E %s: fwrite() failed\n",cmdname);
        perror(">E ");
        exit(1);
    }
    if (doflip)
      { compute_dual_code_mirror(code);
      if (fwrite(code,sizeof(unsigned char),length,f) != length)
	{
	  fprintf(stderr,">E %s: fwrite() failed\n",cmdname);
	  perror(">E ");
	  exit(1);
	}
      }
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x220, %rsp            # imm = 0x220
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movl 0x24fd2c(%rip), %eax    # 0x25a624
addl $0x3, %eax
movl %eax, -0x214(%rbp)
movl 0x24fd1d(%rip), %eax    # 0x25a624
movl $0x2, %ecx
cltd
idivl %ecx
movl %eax, %ecx
movl -0x214(%rbp), %eax
addl %ecx, %eax
subl 0x24fd01(%rip), %eax    # 0x25a620
cltq
movq %rax, -0x18(%rbp)
leaq -0x210(%rbp), %rdi
callq 0xb000
leaq -0x210(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rcx
movl $0x1, %esi
callq 0x10d0
cmpq -0x18(%rbp), %rax
je 0xa985
movq 0x316a1(%rip), %rax     # 0x3bff8
movq (%rax), %rdi
movq 0x3175f(%rip), %rdx     # 0x3c0c0
leaq 0x2daa8(%rip), %rsi     # 0x38410
movb $0x0, %al
callq 0x1060
leaq 0x2da2e(%rip), %rdi     # 0x383a4
callq 0x10a0
movl $0x1, %edi
callq 0x10c0
cmpl $0x0, -0xc(%rbp)
je 0xa9ed
leaq -0x210(%rbp), %rdi
callq 0xb3e0
leaq -0x210(%rbp), %rdi
movq -0x18(%rbp), %rdx
movq -0x8(%rbp), %rcx
movl $0x1, %esi
callq 0x10d0
cmpq -0x18(%rbp), %rax
je 0xa9eb
movq 0x3163b(%rip), %rax     # 0x3bff8
movq (%rax), %rdi
movq 0x316f9(%rip), %rdx     # 0x3c0c0
leaq 0x2da42(%rip), %rsi     # 0x38410
movb $0x0, %al
callq 0x1060
leaq 0x2d9c8(%rip), %rdi     # 0x383a4
callq 0x10a0
movl $0x1, %edi
callq 0x10c0
jmp 0xa9ed
addq $0x220, %rsp            # imm = 0x220
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mishun[P]plantri/plantri.c
// Function: reduce_quadr_P0
static void
reduce_quadr_P0(EDGE *e)

/* reduces a graph previously extended by the P0 extension for
   quadrangulations. The edge e must be the reference edge
   returned by the expansion routine.
*/

{
  register EDGE *dummy, *dummy2;
  int buffer;

  nv--; ne-=4;

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

  dummy->next=dummy2; dummy2->prev=dummy;
  buffer=dummy->start;
  firstedge[buffer]=dummy; degree[buffer]--;

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

  dummy->next=dummy2; dummy2->prev=dummy;
  buffer=dummy->start;
  firstedge[buffer]=dummy; degree[buffer]--;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl 0x24ad52(%rip), %eax    # 0x25a620
addl $-0x1, %eax
movl %eax, 0x24ad49(%rip)    # 0x25a620
movl 0x24ad47(%rip), %eax    # 0x25a624
subl $0x4, %eax
movl %eax, 0x24ad3e(%rip)    # 0x25a624
movq -0x8(%rbp), %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 %rax, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdx
movslq -0x1c(%rbp), %rcx
leaq 0x2e0c6(%rip), %rax     # 0x3da00
movq %rdx, (%rax,%rcx,8)
movslq -0x1c(%rbp), %rcx
leaq 0x2e2b7(%rip), %rax     # 0x3dc00
movl (%rax,%rcx,4), %edx
addl $-0x1, %edx
leaq 0x2e2aa(%rip), %rax     # 0x3dc00
movl %edx, (%rax,%rcx,4)
movq -0x8(%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 %rax, -0x10(%rbp)
movq -0x18(%rbp), %rcx
movq -0x10(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x10(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movq -0x10(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x10(%rbp), %rdx
movslq -0x1c(%rbp), %rcx
leaq 0x2e04f(%rip), %rax     # 0x3da00
movq %rdx, (%rax,%rcx,8)
movslq -0x1c(%rbp), %rcx
leaq 0x2e240(%rip), %rax     # 0x3dc00
movl (%rax,%rcx,4), %edx
addl $-0x1, %edx
leaq 0x2e233(%rip), %rax     # 0x3dc00
movl %edx, (%rax,%rcx,4)
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mishun[P]plantri/plantri.c
// Function: has_quadr_P0
static int
has_quadr_P0(void)

/* Test whether there is a legal P1 reduction */

{
    int i;

    for (i = nv; --i >= 0; )
        if (degree[i] == 2) return TRUE;
    
    return FALSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl 0x24a9d6(%rip), %eax    # 0x25a620
movl %eax, -0x8(%rbp)
movl -0x8(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x8(%rbp)
cmpl $0x0, %eax
jl 0xfc77
movslq -0x8(%rbp), %rcx
leaq 0x2df9a(%rip), %rax     # 0x3dc00
cmpl $0x2, (%rax,%rcx,4)
jne 0xfc75
movl $0x1, -0x4(%rbp)
jmp 0xfc7e
jmp 0xfc4d
movl $0x0, -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: prune_bip_edgelist
static void
prune_bip_edgelist(EDGE *old[], int numold, EDGE *newe[], int *numnew)

/* Copy from old[0..numold-1] to newe[0..*numnew-1] each edge e with
 *    these two properties:
 *       1. Both ends of e have degree >= minpolydeg+1.
 *          2. e is contained in a 4-face.
 *            It is legal that old and newe and &numold and numnew are the same.
 */

{
    int i,counter=0;
    EDGE *e;

    for (i=0; i<numold; i++, old++)
      { e = *old; 
        if (degree[e->start] > minpolydeg && degree[e->end] > minpolydeg
             && (e->left_facesize == 4 || e->invers->left_facesize == 4))
            newe[counter++]=e;
      }

    *numnew=counter;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x28(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x10399
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movslq (%rax), %rcx
leaq 0x2d8da(%rip), %rax     # 0x3dc00
movl (%rax,%rcx,4), %eax
cmpl 0x2be71(%rip), %eax     # 0x3c1a0
jle 0x1037d
movq -0x30(%rbp), %rax
movslq 0x4(%rax), %rcx
leaq 0x2d8c0(%rip), %rax     # 0x3dc00
movl (%rax,%rcx,4), %eax
cmpl 0x2be57(%rip), %eax     # 0x3c1a0
jle 0x1037d
movq -0x30(%rbp), %rax
cmpl $0x4, 0x38(%rax)
je 0x10363
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
cmpl $0x4, 0x38(%rax)
jne 0x1037d
movq -0x30(%rbp), %rdx
movq -0x18(%rbp), %rax
movl -0x28(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x28(%rbp)
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x1037f
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
jmp 0x10301
movl -0x28(%rbp), %ecx
movq -0x20(%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: insert_edge_general
static void
insert_edge_general(EDGE *e)

/* inserts the edge previously deleted -- e may not have been modified in
   the meantime and the map must look exactly like it looked before deleting
   it. There is no special face size required on the left hand side of e */
{
    int newfacesize;
    EDGE *run;

    ne +=2;

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

    e=e->invers;

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

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

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

    e=e->invers; /* back to the old */
    run=e->prev->invers;
    newfacesize=e->left_facesize;
    for (run=e->prev->invers; run != e; run=run->prev->invers)
        run->left_facesize=newfacesize;

}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl 0x247e76(%rip), %eax    # 0x25a624
addl $0x2, %eax
movl %eax, 0x247e6d(%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 0x2b41b(%rip), %rax     # 0x3dc00
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
leaq 0x2b40e(%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 0x2b3d1(%rip), %rax     # 0x3dc00
movl (%rax,%rcx,4), %edx
addl $0x1, %edx
leaq 0x2b3c4(%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 0x1288f
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 0x12869
movq -0x8(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x8(%rbp)
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 0x128eb
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 0x128c5
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mishun[P]plantri/plantri.c
// Function: twoconn_quad
static int
twoconn_quad(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 quadrangle (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 or w=e->invers->next->end MUST be the cutvertex.
   It is checked whether v or w are 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;

    RESETMARKS_V;

    MARK_V(e->prev->end);
    MARK_V(e->invers->next->end);

    end = e->next->invers;

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

   return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl 0x295a2(%rip), %eax     # 0x3c090
addl $0x1, %eax
movl %eax, 0x29599(%rip)     # 0x3c090
cmpl $0x7530, %eax           # imm = 0x7530
jle 0x12b34
movl $0x1, 0x29588(%rip)     # 0x3c090
movl $0x0, -0x24(%rbp)
cmpl $0x40, -0x24(%rbp)
jge 0x12b32
movslq -0x24(%rbp), %rcx
leaq 0x28e120(%rip), %rax    # 0x2a0c40
movl $0x0, (%rax,%rcx,4)
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
jmp 0x12b0f
jmp 0x12b34
movl 0x29556(%rip), %edx     # 0x3c090
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movslq 0x4(%rax), %rcx
leaq 0x28e0f3(%rip), %rax    # 0x2a0c40
movl %edx, (%rax,%rcx,4)
movl 0x2953a(%rip), %edx     # 0x3c090
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x18(%rax), %rax
movslq 0x4(%rax), %rcx
leaq 0x28e0d3(%rip), %rax    # 0x2a0c40
movl %edx, (%rax,%rcx,4)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x20(%rax), %rax
movq %rax, -0x20(%rbp)
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 0x12bd1
movq -0x18(%rbp), %rax
movslq 0x4(%rax), %rcx
leaq 0x28e097(%rip), %rax    # 0x2a0c40
movl (%rax,%rcx,4), %eax
cmpl 0x294de(%rip), %eax     # 0x3c090
jne 0x12bbd
movl $0x0, -0x4(%rbp)
jmp 0x12bd8
jmp 0x12bbf
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x12b90
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mishun[P]plantri/plantri.c
// Function: legal_P1_reduction_all
static int
legal_P1_reduction_all(EDGE *e)

/* checks whether the edge e characterizes a legal P1-reduction.
   General quadrangulations version.
   Returns TRUE if legal, FALSE otherwise.

   It is assumed that edge->start has degree 3, and that there are
   no vertices of degree 2.
*/

{ EDGE *run, *last;
 int w; 

 w=e->end;
 run=e->next->invers->prev->invers;
 last=run->prev;
 run=run->next;

 do { if (run->end==w) return FALSE; run=run->next; } while (run!=last);

 return TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
cmpl -0x24(%rbp), %eax
jne 0x13147
movl $0x0, -0x4(%rbp)
jmp 0x13164
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jne 0x13132
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mishun[P]plantri/plantri.c
// Function: has_quadr_P1
static int
has_quadr_P1(void)

/* Test whether there is a legal P1 reduction */

{
    int i;
    EDGE *e,*elast;

    for (i = 0; i < nv; ++i)
    if (degree[i] == 3)
    {
	e = elast = firstedge[i];
	do
	{
	    if (degree[e->next->end] >= 4 && degree[e->prev->end] >= 4
				      && legal_P1_reduction(e)) return TRUE;
	    e = e->next;
	} while (e != elast);
    }

    return FALSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl 0x2455b8(%rip), %eax    # 0x25a620
jge 0x15107
movslq -0x8(%rbp), %rcx
leaq 0x28b87(%rip), %rax     # 0x3dc00
cmpl $0x3, (%rax,%rcx,4)
jne 0x150f7
movslq -0x8(%rbp), %rcx
leaq 0x28976(%rip), %rax     # 0x3da00
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movslq 0x4(%rax), %rcx
leaq 0x28b57(%rip), %rax     # 0x3dc00
cmpl $0x4, (%rax,%rcx,4)
jl 0x150df
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movslq 0x4(%rax), %rcx
leaq 0x28b3e(%rip), %rax     # 0x3dc00
cmpl $0x4, (%rax,%rcx,4)
jl 0x150df
movq -0x10(%rbp), %rdi
callq 0x159c0
cmpl $0x0, %eax
je 0x150df
movl $0x1, -0x4(%rbp)
jmp 0x1510e
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x15096
jmp 0x150f7
jmp 0x150f9
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x1505f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mishun[P]plantri/plantri.c
// Function: will_be_3_connected
static int
will_be_3_connected(EDGE *e)

/* returns 1 if after performing a P1 expansion for edge e, the graph
   will still be 3-connected, 0 else 

   Uses the fact that there are no 3-cycles.
*/

{
  int end1, end2;
  EDGE *run, *last;

  end1=e->prev->end;
  end2=e->next->end;

  if (degree[end1]<degree[end2])
    { e=e->prev->invers;
    run=e->next; last=e->prev;
    /* end2 cannot be in the face left of run -- would be a double edge 
       and for the same reason not in the face right of last */
    while (run!=last)
      { if (run->invers->prev->end==end2) return 0;
        run=run->next; }
    }
  else     
    { e=e->next->invers;
    run=e->next; last=e->prev;
    while (run!=last)
      { if (run->invers->prev->end==end1) return 0;
        run=run->next; }
    }

  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x4(%rax), %eax
movl %eax, -0x14(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movl 0x4(%rax), %eax
movl %eax, -0x18(%rbp)
movslq -0x14(%rbp), %rcx
leaq 0x28321(%rip), %rax     # 0x3dc00
movl (%rax,%rcx,4), %eax
movslq -0x18(%rbp), %rdx
leaq 0x28313(%rip), %rcx     # 0x3dc00
cmpl (%rcx,%rdx,4), %eax
jge 0x15951
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, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
je 0x1594f
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rax
movl 0x4(%rax), %eax
cmpl -0x18(%rbp), %eax
jne 0x15941
movl $0x0, -0x4(%rbp)
jmp 0x159b7
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x1591a
jmp 0x159b0
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x28(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
je 0x159ae
movq -0x20(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rax
movl 0x4(%rax), %eax
cmpl -0x14(%rbp), %eax
jne 0x159a0
movl $0x0, -0x4(%rbp)
jmp 0x159b7
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x15979
jmp 0x159b0
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mishun[P]plantri/plantri.c
// Function: legal_P1_reduction
static int
legal_P1_reduction(EDGE *e)

/* checks whether the edge e characterizes a legal P1-reduction.
   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 *run, *last;
 int v,w,w1,w2, buffer; 

 w=e->end;
 run=e->next->invers->prev->invers;
 last=run->prev;
 run=run->next;
 v=run->start;

 do { if (run->end==w) return 0; run=run->next; } while (run!=last);

 e=e->invers;
 w1=e->next->end;
 w2=e->prev->end;


 /* OK -- then some serious tests have to be done... */

 run=last->next;
 last=last->prev;
 
 if (run->invers->prev->end==w1) return 0;
 /* cannot be w2 */
 for (run=run->next; run!=last; run=run->next)
   { buffer=run->invers->prev->end;
   if (buffer==w1) return 0;
   if (buffer==w2) return 0;
   }

 /* the last one cannot be w1 */
 if (run->invers->prev->end==w2) return 0;

 /* All tests successful -- no 2-cut will occur: */

 return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x28(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
cmpl -0x28(%rbp), %eax
jne 0x15a23
movl $0x0, -0x4(%rbp)
jmp 0x15b14
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jne 0x15a0b
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movl 0x4(%rax), %eax
movl %eax, -0x2c(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movl 0x4(%rax), %eax
movl %eax, -0x30(%rbp)
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x20(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rax
movl 0x4(%rax), %eax
cmpl -0x2c(%rbp), %eax
jne 0x15a96
movl $0x0, -0x4(%rbp)
jmp 0x15b14
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
je 0x15af0
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rax
movl 0x4(%rax), %eax
movl %eax, -0x34(%rbp)
movl -0x34(%rbp), %eax
cmpl -0x2c(%rbp), %eax
jne 0x15acf
movl $0x0, -0x4(%rbp)
jmp 0x15b14
movl -0x34(%rbp), %eax
cmpl -0x30(%rbp), %eax
jne 0x15ae0
movl $0x0, -0x4(%rbp)
jmp 0x15b14
jmp 0x15ae2
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x15aa2
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rax
movl 0x4(%rax), %eax
cmpl -0x30(%rbp), %eax
jne 0x15b0d
movl $0x0, -0x4(%rbp)
jmp 0x15b14
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mishun[P]plantri/plantri.c
// Function: has_quadr_P1_min3
static int
has_quadr_P1_min3(void)

/* Test whether there is a legal P1 reduction, mindeg3 version.
   It is enough that there is a vertex of degree 3 with at least
   two neighbours of degree at least 4.
*/

{
    int i,n3;
    EDGE *e;

    for (i = 0; i < nv; ++i)
    if (degree[i] == 3)
    {
        e = firstedge[i];
	n3 = 0;
	if (degree[e->end] == 3) ++n3;
	e = e->next;
	if (degree[e->end] == 3) ++n3;
	e = e->next;
	if (degree[e->end] == 3) ++n3;
        
	if (n3 <= 1) return TRUE;
    }

    return FALSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
cmpl 0x2438ec(%rip), %eax    # 0x25a620
jge 0x16dfc
movslq -0x8(%rbp), %rcx
leaq 0x26ebb(%rip), %rax     # 0x3dc00
cmpl $0x3, (%rax,%rcx,4)
jne 0x16dec
movslq -0x8(%rbp), %rcx
leaq 0x26ca6(%rip), %rax     # 0x3da00
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movl $0x0, -0xc(%rbp)
movq -0x18(%rbp), %rax
movslq 0x4(%rax), %rcx
leaq 0x26e88(%rip), %rax     # 0x3dc00
cmpl $0x3, (%rax,%rcx,4)
jne 0x16d87
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movslq 0x4(%rax), %rcx
leaq 0x26e5e(%rip), %rax     # 0x3dc00
cmpl $0x3, (%rax,%rcx,4)
jne 0x16db1
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movslq 0x4(%rax), %rcx
leaq 0x26e34(%rip), %rax     # 0x3dc00
cmpl $0x3, (%rax,%rcx,4)
jne 0x16ddb
movl -0xc(%rbp), %eax
addl $0x1, %eax
movl %eax, -0xc(%rbp)
cmpl $0x1, -0xc(%rbp)
jg 0x16dea
movl $0x1, -0x4(%rbp)
jmp 0x16e03
jmp 0x16dec
jmp 0x16dee
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x16d2b
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mishun[P]plantri/plantri.c
// Function: legal_P1_reduction_min3
static int
legal_P1_reduction_min3(EDGE *e)

/* checks whether the edge e characterizes a legal P1-reduction.
   mindeg 3 version
   Returns TRUE if yes, FALSE 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 *run, *last;
 int w; 

 w=e->end;
 run=e->next->invers->prev->invers;
 last=run->prev;
 run=run->next;

 do { if (run->end==w) return FALSE; run=run->next; } while (run!=last);

 return TRUE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movl 0x4(%rax), %eax
movl %eax, -0x24(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rax
movq 0x20(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movl 0x4(%rax), %eax
cmpl -0x24(%rbp), %eax
jne 0x17427
movl $0x0, -0x4(%rbp)
jmp 0x17444
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
cmpq -0x20(%rbp), %rax
jne 0x17412
movl $0x1, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nopl (%rax)
// File: /workspace/github_c_makefile_star2_O0/mishun[P]plantri/plantri.c
// Function: legal_P3_reduction_min3
static int
legal_P3_reduction_min3(EDGE *e)

/* checks whether the edge corresponds to a legal P3 reduction.
   Returns 1 if it is a legal reduction, 0 else. 
   mindeg 3 version

   Again it is assumed (necessary or not) that P1 has higher priority
   -- the nonexistence of a P1 reduction forces some subconfiguration.

   Furthermore it is assumed that the graph inspected is not the cube.
*/

{
  EDGE *run;
  int v1;

  if (degree[e->next->end]!=3) return 0;
  run=e->invers->prev;
  if (degree[run->end]!=3) return 0;
  run=run->prev->invers->prev;  
  if (degree[run->end]!=3) return 0;
  v1=run->start;
  run=run->prev->invers->prev;  
  if (degree[run->end]!=3) return 0;
 
  return 1;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movslq 0x4(%rax), %rcx
leaq 0x26795(%rip), %rax     # 0x3dc00
cmpl $0x3, (%rax,%rcx,4)
je 0x1747d
movl $0x0, -0x4(%rbp)
jmp 0x1751f
movq -0x10(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movslq 0x4(%rax), %rcx
leaq 0x26764(%rip), %rax     # 0x3dc00
cmpl $0x3, (%rax,%rcx,4)
je 0x174ab
movl $0x0, -0x4(%rbp)
jmp 0x1751f
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movslq 0x4(%rax), %rcx
leaq 0x26732(%rip), %rax     # 0x3dc00
cmpl $0x3, (%rax,%rcx,4)
je 0x174dd
movl $0x0, -0x4(%rbp)
jmp 0x1751f
movq -0x18(%rbp), %rax
movl (%rax), %eax
movl %eax, -0x1c(%rbp)
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rax
movslq 0x4(%rax), %rcx
leaq 0x266f7(%rip), %rax     # 0x3dc00
cmpl $0x3, (%rax,%rcx,4)
je 0x17518
movl $0x0, -0x4(%rbp)
jmp 0x1751f
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: all_5_bangles
static void
all_5_bangles(EDGE **bang, int *nbang)

/* Set bang[0..nbang-1] to the central edges (min) of all bangles.
   5-connected case. */

{
    int i,nb;
    EDGE *e,*elast;

    nb = 0;
    for (i = 0; i < nv; ++i)
    {
	e = elast = firstedge[i];
	do
	{
	    if (e == e->min && is_in_5_bangle(e)) bang[nb++] = e;
	    e = e->next;
	} while (e != elast);
    }

    *nbang = nb;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x30, %rsp
movq %rdi, -0x8(%rbp)
movq %rsi, -0x10(%rbp)
movl $0x0, -0x18(%rbp)
movl $0x0, -0x14(%rbp)
movl -0x14(%rbp), %eax
cmpl 0x241b59(%rip), %eax    # 0x25a620
jge 0x18b39
movslq -0x14(%rbp), %rcx
leaq 0x24f2c(%rip), %rax     # 0x3da00
movq (%rax,%rcx,8), %rax
movq %rax, -0x28(%rbp)
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
movq -0x20(%rbp), %rcx
cmpq 0x28(%rcx), %rax
jne 0x18b16
movq -0x20(%rbp), %rdi
callq 0x1c1c0
cmpl $0x0, %eax
je 0x18b16
movq -0x20(%rbp), %rdx
movq -0x8(%rbp), %rax
movl -0x18(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x18(%rbp)
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rax
cmpq -0x28(%rbp), %rax
jne 0x18ae0
jmp 0x18b2e
movl -0x14(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x14(%rbp)
jmp 0x18abe
movl -0x18(%rbp), %ecx
movq -0x10(%rbp), %rax
movl %ecx, (%rax)
addq $0x30, %rsp
popq %rbp
retq
nopl (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mishun[P]plantri/plantri.c
// Function: make_cycle
static void
make_cycle(int n)

/* Makes a cycle on n vertices and uses the first 2n edges of the
   vector edges[] for it. Interpretation: a 1-cycle is a loop,
   a 2-cycle a double-edge. */

{
   int i, end;
   EDGE *buffer, *bufferb;

   /* edges+2*i always leads from i to i+1 (mod n) and edges+2*i+1
      leads back. */

   for (i=0;i<=n-1;i++)
     { end=(i+1)%n;
     degree[i]=2;
     buffer=edges+(2*i);
     firstedge[i]=buffer;
     bufferb=buffer+1;
     buffer->invers=bufferb;
     bufferb->invers=buffer;
     buffer->min=bufferb->min=buffer;
     buffer->start=bufferb->end=i;
     bufferb->start=buffer->end=end;
     if (i>0) buffer->prev=buffer->next=buffer-1;
     else buffer->prev=buffer->next=edges+2*n-1;
     if (i<n-1) bufferb->prev=bufferb->next=bufferb+1;
     else bufferb->prev=bufferb->next=edges;
     }

   nv=n; ne=2*n;

   return;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movl %edi, -0x4(%rbp)
movl $0x0, -0x8(%rbp)
movl -0x8(%rbp), %eax
movl -0x4(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jg 0x1b251
movl -0x8(%rbp), %eax
addl $0x1, %eax
cltd
idivl -0x4(%rbp)
movl %edx, -0xc(%rbp)
movslq -0x8(%rbp), %rcx
leaq 0x22ad9(%rip), %rax     # 0x3dc00
movl $0x2, (%rax,%rcx,4)
movl -0x8(%rbp), %eax
shll %eax
movslq %eax, %rcx
leaq 0x23f4f3(%rip), %rax    # 0x25a630
shlq $0x6, %rcx
addq %rcx, %rax
movq %rax, -0x18(%rbp)
movq -0x18(%rbp), %rdx
movslq -0x8(%rbp), %rcx
leaq 0x228a9(%rip), %rax     # 0x3da00
movq %rdx, (%rax,%rcx,8)
movq -0x18(%rbp), %rax
addq $0x40, %rax
movq %rax, -0x20(%rbp)
movq -0x20(%rbp), %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x20(%rax)
movq -0x18(%rbp), %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x28(%rax)
movq -0x18(%rbp), %rax
movq %rcx, 0x28(%rax)
movl -0x8(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x18(%rbp), %rax
movl %ecx, (%rax)
movl -0xc(%rbp), %ecx
movq -0x18(%rbp), %rax
movl %ecx, 0x4(%rax)
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
cmpl $0x0, -0x8(%rbp)
jle 0x1b1d3
movq -0x18(%rbp), %rcx
addq $-0x40, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x1b1fc
movl -0x4(%rbp), %eax
shll %eax
cltq
leaq 0x23f44f(%rip), %rcx    # 0x25a630
shlq $0x6, %rax
addq %rax, %rcx
addq $-0x40, %rcx
movq -0x18(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x18(%rbp), %rax
movq %rcx, 0x10(%rax)
movl -0x8(%rbp), %eax
movl -0x4(%rbp), %ecx
subl $0x1, %ecx
cmpl %ecx, %eax
jge 0x1b223
movq -0x20(%rbp), %rcx
addq $0x40, %rcx
movq -0x20(%rbp), %rax
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
movq %rcx, 0x10(%rax)
jmp 0x1b241
movq -0x20(%rbp), %rax
leaq 0x23f402(%rip), %rcx    # 0x25a630
movq %rcx, 0x18(%rax)
movq -0x20(%rbp), %rax
leaq 0x23f3f3(%rip), %rcx    # 0x25a630
movq %rcx, 0x10(%rax)
jmp 0x1b243
movl -0x8(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x8(%rbp)
jmp 0x1b0fe
movl -0x4(%rbp), %eax
movl %eax, 0x23f3c6(%rip)    # 0x25a620
movl -0x4(%rbp), %eax
shll %eax
movl %eax, 0x23f3bf(%rip)    # 0x25a624
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mishun[P]plantri/plantri.c
// Function: is_in_5_bangle
static int
is_in_5_bangle(EDGE *e)

/* Test if e is the central edge of a bangle, 5-connected case. */

{
    EDGE *e1,*e2;
    int k,l;

    RESETMARKS_V;
    for (e1 = e->prev->invers->next->next, k = degree[e->prev->end]-4;
                                                 --k >= 0; e1 = e1->next)
        MARK_V(e1->end);

    for (e1 = e->next->invers->prev->prev, k = degree[e->next->end]-4;
                                                 --k >= 0; e1 = e1->prev)
        for (e2 = e1->invers->next->next, l = degree[e1->end]-3;
                                                 --l >= 0; e2 = e2->next)
            if (ISMARKED_V(e2->end)) return TRUE;

    return FALSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x10(%rbp)
movl 0x1fec2(%rip), %eax     # 0x3c090
addl $0x1, %eax
movl %eax, 0x1feb9(%rip)     # 0x3c090
cmpl $0x7530, %eax           # imm = 0x7530
jle 0x1c214
movl $0x1, 0x1fea8(%rip)     # 0x3c090
movl $0x0, -0x2c(%rbp)
cmpl $0x40, -0x2c(%rbp)
jge 0x1c212
movslq -0x2c(%rbp), %rcx
leaq 0x284a40(%rip), %rax    # 0x2a0c40
movl $0x0, (%rax,%rcx,4)
movl -0x2c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x2c(%rbp)
jmp 0x1c1ef
jmp 0x1c214
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movq 0x20(%rax), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movslq 0x4(%rax), %rcx
leaq 0x219c1(%rip), %rax     # 0x3dc00
movl (%rax,%rcx,4), %eax
subl $0x4, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
jl 0x1c27c
movl 0x1fe34(%rip), %edx     # 0x3c090
movq -0x18(%rbp), %rax
movslq 0x4(%rax), %rcx
leaq 0x2849d5(%rip), %rax    # 0x2a0c40
movl %edx, (%rax,%rcx,4)
movq -0x18(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x1c248
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq 0x20(%rax), %rax
movq 0x10(%rax), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movslq 0x4(%rax), %rcx
leaq 0x21959(%rip), %rax     # 0x3dc00
movl (%rax,%rcx,4), %eax
subl $0x4, %eax
movl %eax, -0x24(%rbp)
movl -0x24(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x24(%rbp)
cmpl $0x0, %eax
jl 0x1c342
movq -0x18(%rbp), %rax
movq 0x20(%rax), %rax
movq 0x18(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
movq -0x18(%rbp), %rax
movslq 0x4(%rax), %rcx
leaq 0x2191b(%rip), %rax     # 0x3dc00
movl (%rax,%rcx,4), %eax
subl $0x3, %eax
movl %eax, -0x28(%rbp)
movl -0x28(%rbp), %eax
addl $-0x1, %eax
movl %eax, -0x28(%rbp)
cmpl $0x0, %eax
jl 0x1c32f
movq -0x20(%rbp), %rax
movslq 0x4(%rax), %rcx
leaq 0x284935(%rip), %rax    # 0x2a0c40
movl (%rax,%rcx,4), %eax
cmpl 0x1fd7c(%rip), %eax     # 0x3c090
jne 0x1c31f
movl $0x1, -0x4(%rbp)
jmp 0x1c349
jmp 0x1c321
movq -0x20(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x20(%rbp)
jmp 0x1c2ee
jmp 0x1c331
movq -0x18(%rbp), %rax
movq 0x10(%rax), %rax
movq %rax, -0x18(%rbp)
jmp 0x1c2b0
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
popq %rbp
retq
nop
// File: /workspace/github_c_makefile_star2_O0/mishun[P]plantri/plantri.c
// Function: has_min5_a
static int
has_min5_a(void)

/* Test if the graph has an A-reduction */

{
    EDGE *e,*elast;
    int i;

    for (i = 0; i < nv; ++i)
    {
        e = elast = firstedge[i];
        do
        {
            if (e == e->min && degree[e->next->end] >= 6
                    && degree[e->prev->end] >= 6 && !on_nf_5_cycle(e))
                return TRUE;
            e = e->next;
        } while (e != elast);
    }

    return FALSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl 0x23b838(%rip), %eax    # 0x25a620
jge 0x1ee82
movslq -0x1c(%rbp), %rcx
leaq 0x1ec07(%rip), %rax     # 0x3da00
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x28(%rcx), %rax
jne 0x1ee5c
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movslq 0x4(%rax), %rcx
leaq 0x1edda(%rip), %rax     # 0x3dc00
cmpl $0x6, (%rax,%rcx,4)
jl 0x1ee5c
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movslq 0x4(%rax), %rcx
leaq 0x1edc1(%rip), %rax     # 0x3dc00
cmpl $0x6, (%rax,%rcx,4)
jl 0x1ee5c
movq -0x10(%rbp), %rdi
callq 0x275c0
cmpl $0x0, %eax
jne 0x1ee5c
movl $0x1, -0x4(%rbp)
jmp 0x1ee89
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x1ee05
jmp 0x1ee74
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1eddf
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw %cs:(%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mishun[P]plantri/plantri.c
// Function: has_min5_b
static int
has_min5_b(void)

/* Test if the graph has a B-reduction */ 

{
    EDGE *e,*elast;
    int i;

    for (i = 0; i < nv; ++i)
    if (degree[i] == 5)
    {
        e = elast = firstedge[i];
        do  
        {
            if (e == e->min && degree[e->end] == 5
                    && degree[e->prev->end] == 5
                    && degree[e->next->end] == 5
		    && (is_valid_min5_b(e,FALSE) || is_valid_min5_b(e,TRUE)))
                return TRUE;
            e = e->next;
        } while (e != elast);
    }

    return FALSE;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
subq $0x20, %rsp
movl $0x0, -0x1c(%rbp)
movl -0x1c(%rbp), %eax
cmpl 0x23a9b8(%rip), %eax    # 0x25a620
jge 0x1fd47
movslq -0x1c(%rbp), %rcx
leaq 0x1df87(%rip), %rax     # 0x3dc00
cmpl $0x5, (%rax,%rcx,4)
jne 0x1fd37
movslq -0x1c(%rbp), %rcx
leaq 0x1dd72(%rip), %rax     # 0x3da00
movq (%rax,%rcx,8), %rax
movq %rax, -0x18(%rbp)
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
movq -0x10(%rbp), %rcx
cmpq 0x28(%rcx), %rax
jne 0x1fd1b
movq -0x10(%rbp), %rax
movslq 0x4(%rax), %rcx
leaq 0x1df49(%rip), %rax     # 0x3dc00
cmpl $0x5, (%rax,%rcx,4)
jne 0x1fd1b
movq -0x10(%rbp), %rax
movq 0x10(%rax), %rax
movslq 0x4(%rax), %rcx
leaq 0x1df30(%rip), %rax     # 0x3dc00
cmpl $0x5, (%rax,%rcx,4)
jne 0x1fd1b
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movslq 0x4(%rax), %rcx
leaq 0x1df17(%rip), %rax     # 0x3dc00
cmpl $0x5, (%rax,%rcx,4)
jne 0x1fd1b
movq -0x10(%rbp), %rdi
xorl %esi, %esi
callq 0x27b10
cmpl $0x0, %eax
jne 0x1fd12
movq -0x10(%rbp), %rdi
movl $0x1, %esi
callq 0x27b10
cmpl $0x0, %eax
je 0x1fd1b
movl $0x1, -0x4(%rbp)
jmp 0x1fd4e
movq -0x10(%rbp), %rax
movq 0x18(%rax), %rax
movq %rax, -0x10(%rbp)
movq -0x10(%rbp), %rax
cmpq -0x18(%rbp), %rax
jne 0x1fc9a
jmp 0x1fd37
jmp 0x1fd39
movl -0x1c(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x1c(%rbp)
jmp 0x1fc5f
movl $0x0, -0x4(%rbp)
movl -0x4(%rbp), %eax
addq $0x20, %rsp
popq %rbp
retq
nopw (%rax,%rax)
// File: /workspace/github_c_makefile_star2_O0/mishun[P]plantri/plantri.c
// Function: prune_poly_edgelist
static void
prune_poly_edgelist(EDGE *old[], int numold, EDGE *newe[], int *numnew)

/* Copy from old[0..numold-1] to newe[0..*numnew-1] each edge e with
   these two properties:
   1. Both ends of e have degree >= minpolydeg+1.
   2. e is contained in a 3-face.
   It is legal that old and newe and &numold and numnew are the same.

   17Aug2005: Changed "new" to "newe" to avoid Codewarrior bug.
*/

{
    int i,counter=0;
    EDGE *e;

    for (i=0; i<numold; i++, old++)
      { e = *old; 
        if (degree[e->start] > minpolydeg && degree[e->end] > minpolydeg
	     && (e->left_facesize == 3 || e->invers->left_facesize == 3))
            newe[counter++]=e;
      }

    *numnew=counter;
}

// Assembly:
pushq %rbp
movq %rsp, %rbp
movq %rdi, -0x8(%rbp)
movl %esi, -0xc(%rbp)
movq %rdx, -0x18(%rbp)
movq %rcx, -0x20(%rbp)
movl $0x0, -0x28(%rbp)
movl $0x0, -0x24(%rbp)
movl -0x24(%rbp), %eax
cmpl -0xc(%rbp), %eax
jge 0x202d9
movq -0x8(%rbp), %rax
movq (%rax), %rax
movq %rax, -0x30(%rbp)
movq -0x30(%rbp), %rax
movslq (%rax), %rcx
leaq 0x1d99a(%rip), %rax     # 0x3dc00
movl (%rax,%rcx,4), %eax
cmpl 0x1bf31(%rip), %eax     # 0x3c1a0
jle 0x202bd
movq -0x30(%rbp), %rax
movslq 0x4(%rax), %rcx
leaq 0x1d980(%rip), %rax     # 0x3dc00
movl (%rax,%rcx,4), %eax
cmpl 0x1bf17(%rip), %eax     # 0x3c1a0
jle 0x202bd
movq -0x30(%rbp), %rax
cmpl $0x3, 0x38(%rax)
je 0x202a3
movq -0x30(%rbp), %rax
movq 0x20(%rax), %rax
cmpl $0x3, 0x38(%rax)
jne 0x202bd
movq -0x30(%rbp), %rdx
movq -0x18(%rbp), %rax
movl -0x28(%rbp), %ecx
movl %ecx, %esi
addl $0x1, %esi
movl %esi, -0x28(%rbp)
movslq %ecx, %rcx
movq %rdx, (%rax,%rcx,8)
jmp 0x202bf
movl -0x24(%rbp), %eax
addl $0x1, %eax
movl %eax, -0x24(%rbp)
movq -0x8(%rbp), %rax
addq $0x8, %rax
movq %rax, -0x8(%rbp)
jmp 0x20241
movl -0x28(%rbp), %ecx
movq -0x20(%rbp), %rax
movl %ecx, (%rax)
popq %rbp
retq
nopw %cs:(%rax,%rax)