// File: /workspace/github_c_makefile_star2_O3/mishun[P]plantri/fullgen.c
// Function: suchestart
KANTE *suchestart( KANTE *start)
/* belegt eine sequenz und sucht die kanonische Kante mit dem kleinsten Namen 
   arbeitet "invers", d.h. es wird als Innenrand gesehen, der gefuellt werden
   muss. Wird aufgerufen fuer Brille und Sandwich. Start muss eine Kante sein, die
   ins innere zeigt.*/

{
int i, j, k, zaehler, position;
KANTE *run;
int sequenz[7]; 
KANTE *seqkanten[7];
int puffer[7];
char kan[7];



while (start->next->invers->next->invers->next->name == aussen) 
                      start=start->next->invers->next->invers->next;
/* Sucht 2 Kanten hintereinander nach aussen -- zu unterscheiden vom namen aussen, was 
   auch nach innen heissen kann. Duerfte nur fuer bauchbinden eine Endlosschleife sein */

for (i=0; i<7; i++) { sequenz[i]=leer; seqkanten[i]=nil; kan[i]=0; }

position=0;
seqkanten[0]=start;


for (zaehler=1, run=start;
     run->prev->invers->prev->invers->prev->name == aussen;
     run=run->prev->invers->prev->invers->prev) zaehler++;
sequenz[0]=zaehler; position=1; seqkanten[1]=nil;
for (run=run->prev->invers->prev->invers->prev->invers->prev; run->name != aussen;
     run=run->invers->prev) 
{ sequenz[position]=0; position++; seqkanten[position]=nil; }
/* naechste Kante vor nicht-0-sequenz suchen -- entsprechende innenkanten gibt es nicht
   und muessen sich dementsprechend auch nicht gemerkt werden */


while (run != start)
{
seqkanten[position]=run;
for (zaehler=1; 
     run->prev->invers->prev->invers->prev->name == aussen;
     run=run->prev->invers->prev->invers->prev) { zaehler++; }
sequenz[position]=zaehler; position++; seqkanten[position]=nil;
for (run=run->prev->invers->prev->invers->prev->invers->prev; run->name != aussen;
     run=run->invers->prev) 
{ sequenz[position]=0; position++; seqkanten[position]=nil; }
}


sequenz[position]=leer; seqkanten[position]=nil;

kan[0]=sequenz_kanonisch(sequenz);


for (i=0; sequenz[i] != leer; i++)
  { for (j=i, k=0; sequenz[j]!=leer; j++, k++) puffer[k]=sequenz[j];
    for (j=0; j<i; j++, k++) puffer[k]=sequenz[j];
    puffer[k]=leer;
    kan[i]=sequenz_kanonisch(puffer);
  }



for (i=0, run=nil; sequenz[i] != leer; i++)
  { if (kan[i])
      if ((run==nil) || (seqkanten[i]->ursprung < run->ursprung)) run=seqkanten[i];
  }

/* Jetzt die vorige Innenkante suchen, um rechts davon dann einfuegen zu koennen */
for (run=run->next->invers->next->invers->next; run->name != aussen; run=run->invers->next);


return(run);


}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x98, %rsp
movq %rdi, %rax
movq 0x20(%rdi), %rcx
movq 0x28(%rcx), %rcx
movq 0x20(%rcx), %rcx
movq 0x28(%rcx), %rcx
movq 0x20(%rcx), %rdi
cmpw $0x246, 0x2(%rdi)       # imm = 0x246
je 0xcfb1
xorps %xmm0, %xmm0
movaps %xmm0, 0x30(%rsp)
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
movq $0x0, 0x60(%rsp)
xorl %ecx, %ecx
movl %ecx, 0x8(%rsp)
movl %ecx, 0xb(%rsp)
movaps 0x3064(%rip), %xmm0     # 0x10060
movaps %xmm0, 0x10(%rsp)
movabsq $0xfffe0000fffe, %rdx   # imm = 0xFFFE0000FFFE
movq %rdx, 0x20(%rsp)
movl $0xfffe, 0x28(%rsp)     # imm = 0xFFFE
movq %rax, 0x30(%rsp)
movq %rax, %rdx
movq 0x18(%rdx), %rdx
movq 0x28(%rdx), %rdx
movq 0x18(%rdx), %rdx
movq 0x28(%rdx), %rdx
movq 0x18(%rdx), %rdx
incl %ecx
cmpw $0x246, 0x2(%rdx)       # imm = 0x246
je 0xd020
movl %ecx, 0x10(%rsp)
movq $0x0, 0x38(%rsp)
movq 0x28(%rdx), %rcx
movq 0x18(%rcx), %rdx
movl $0x1, %ecx
cmpw $0x246, 0x2(%rdx)       # imm = 0x246
je 0xd089
movl $0x1, %ecx
movl $0x0, 0x10(%rsp,%rcx,4)
movq $0x0, 0x38(%rsp,%rcx,8)
incq %rcx
movq 0x28(%rdx), %rdx
movq 0x18(%rdx), %rdx
cmpw $0x246, 0x2(%rdx)       # imm = 0x246
jne 0xd065
cmpq %rax, %rdx
je 0xd135
leaq 0x38(%rsp), %rsi
movslq %ecx, %rdi
movq %rdx, 0x30(%rsp,%rdi,8)
xorl %ecx, %ecx
movq %rdx, %r8
movq 0x18(%rdx), %rdx
movq 0x28(%rdx), %rdx
movq 0x18(%rdx), %rdx
movq 0x28(%rdx), %rdx
movq 0x18(%rdx), %rdx
incl %ecx
cmpw $0x246, 0x2(%rdx)       # imm = 0x246
je 0xd0a1
movl %ecx, 0x10(%rsp,%rdi,4)
leal 0x1(%rdi), %ecx
movq $0x0, 0x38(%rsp,%rdi,8)
movq 0x18(%r8), %rdx
movq 0x28(%rdx), %rdx
movq 0x18(%rdx), %rdx
movq 0x28(%rdx), %rdx
movq 0x18(%rdx), %rdx
movq 0x28(%rdx), %rdx
movq 0x18(%rdx), %rdx
cmpw $0x246, 0x2(%rdx)       # imm = 0x246
je 0xd12c
incq %rdi
leaq (%rsp,%rdi,4), %r8
addq $0x10, %r8
leaq (%rsi,%rdi,8), %r9
xorl %edi, %edi
movl $0x0, (%r8,%rdi,4)
movq $0x0, (%r9,%rdi,8)
movq 0x28(%rdx), %rdx
movq 0x18(%rdx), %rdx
incq %rdi
cmpw $0x246, 0x2(%rdx)       # imm = 0x246
jne 0xd107
addl %edi, %ecx
cmpq %rax, %rdx
jne 0xd097
movslq %ecx, %rax
movl $0xfffe, %ebp           # imm = 0xFFFE
movl %ebp, 0x10(%rsp,%rax,4)
movq $0x0, 0x30(%rsp,%rax,8)
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x48b3
movb %al, 0x8(%rsp)
movl (%rbx), %eax
cmpl %ebp, %eax
je 0xd1df
leaq 0x14(%rsp), %r15
xorl %r12d, %r12d
leaq 0x70(%rsp), %rbx
leaq 0x10(%rsp), %r14
leaq (,%r12,4), %rdx
xorl %ecx, %ecx
xorl %r13d, %r13d
movl %eax, 0x70(%rsp,%rcx)
incq %r13
movl (%r15,%rcx), %eax
addq $0x4, %rcx
cmpl $0xfffe, %eax           # imm = 0xFFFE
jne 0xd180
testq %r12, %r12
je 0xd1bb
movabsq $0x3fffffffc, %rax      # imm = 0x3FFFFFFFC
andq %rax, %rcx
leaq (%rsp,%rcx), %rdi
addq $0x70, %rdi
movq %r14, %rsi
callq 0x10d0
addl %r12d, %r13d
movl %r13d, %eax
movl %ebp, 0x70(%rsp,%rax,4)
movq %rbx, %rdi
callq 0x48b3
movb %al, 0x8(%rsp,%r12)
movl 0x14(%rsp,%r12,4), %eax
incq %r12
addq $0x4, %r15
cmpl %ebp, %eax
jne 0xd173
xorl %eax, %eax
xorl %ecx, %ecx
cmpb $0x0, 0x8(%rsp,%rax)
je 0xd202
movq 0x30(%rsp,%rax,8), %rdx
testq %rcx, %rcx
je 0xd1ff
movzwl (%rdx), %esi
cmpw (%rcx), %si
jb 0xd1ff
movq %rcx, %rdx
movq %rdx, %rcx
cmpl $0xfffe, 0x14(%rsp,%rax,4) # imm = 0xFFFE
leaq 0x1(%rax), %rax
jne 0xd1e3
movq 0x20(%rcx), %rax
movq 0x28(%rax), %rax
movq 0x20(%rax), %rax
movq 0x28(%rax), %rax
movq 0x20(%rax), %rax
cmpw $0x246, 0x2(%rax)       # imm = 0x246
jne 0xd21c
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq