// File: /workspace/github_c_makefile_star2_O2/mishun[P]plantri/fullgen.c
// Function: suchestart_reko
KANTE *suchestart_reko( KANTE *start, int *fuenfecke)
/* 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.
   Funktioniert wie suchestart, nur dass mininame statt name benutzt wird und die
   Anzahl der 5-Ecke auch berechnet wird */

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



while (start->next->invers->next->invers->next->mininame == 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; }

sqlaenge=0;
position=0;
seqkanten[0]=start;


for (zaehler=1, run=start;
     run->prev->invers->prev->invers->prev->mininame == 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->mininame != 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->mininame == 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->mininame != aussen;
     run=run->invers->prev) 
{ sequenz[position]=0; position++; seqkanten[position]=nil; }
}


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

*fuenfecke=6-sqlaenge;

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]->dummy < run->dummy)) run=seqkanten[i];
      /* dummy ersetzt ursprung */
  }

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


return(run);

}

// Assembly:
pushq %r15
pushq %r14
pushq %rbx
subq $0x90, %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, 0x14(%rdi)      # imm = 0x246
je 0x5c7f
xorl %ecx, %ecx
cmpq $0x7, %rcx
je 0x5cbe
andq $0x0, 0x50(%rsp,%rcx,8)
movl $0xfffe, 0x10(%rsp,%rcx,4) # imm = 0xFFFE
movb $0x0, 0x9(%rsp,%rcx)
incq %rcx
jmp 0x5ca0
movq %rax, 0x50(%rsp)
xorl %ecx, %ecx
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, 0x14(%rdx)      # imm = 0x246
je 0x5cc8
movl %ecx, 0x10(%rsp)
pushq $0x1
popq %rcx
andq $0x0, 0x50(%rsp,%rcx,8)
movq 0x28(%rdx), %rdx
movq 0x18(%rdx), %rdx
cmpw $0x246, 0x14(%rdx)      # imm = 0x246
je 0x5d0d
andl $0x0, 0x10(%rsp,%rcx,4)
incq %rcx
jmp 0x5ced
movabsq $0x100000000, %rdi      # imm = 0x100000000
cmpq %rax, %rdx
je 0x5da1
movslq %ecx, %r8
movq %rdx, 0x50(%rsp,%r8,8)
xorl %r9d, %r9d
movq %rdx, %r10
movq 0x18(%rdx), %rdx
movq 0x28(%rdx), %rdx
movq 0x18(%rdx), %rdx
movq 0x28(%rdx), %rdx
movq 0x18(%rdx), %rdx
incl %r9d
cmpw $0x246, 0x14(%rdx)      # imm = 0x246
je 0x5d2b
shlq $0x20, %rcx
addq %rdi, %rcx
movq %rcx, %r11
sarq $0x1d, %rcx
andq $0x0, 0x50(%rsp,%rcx)
movl %r9d, 0x10(%rsp,%r8,4)
sarq $0x20, %r11
movq 0x18(%r10), %rcx
movq 0x28(%rcx), %rcx
movq 0x18(%rcx), %rcx
movq 0x28(%rcx), %rcx
movq 0x18(%rcx), %rdx
movq %r11, %rcx
movq 0x28(%rdx), %rdx
movq 0x18(%rdx), %rdx
cmpw $0x246, 0x14(%rdx)      # imm = 0x246
je 0x5d17
andl $0x0, 0x10(%rsp,%rcx,4)
andq $0x0, 0x58(%rsp,%rcx,8)
incq %rcx
jmp 0x5d81
movslq %ecx, %rax
andq $0x0, 0x50(%rsp,%rax,8)
movl $0xfffe, 0x10(%rsp,%rax,4) # imm = 0xFFFE
pushq $0x6
popq %rcx
subl %eax, %ecx
movl %ecx, (%rsi)
leaq 0x10(%rsp), %rdi
callq 0x2d7d
movb %al, 0x9(%rsp)
leaq 0x14(%rsp), %r14
xorl %r15d, %r15d
leaq 0x30(%rsp), %rbx
movl 0x10(%rsp,%r15,4), %ecx
xorl %eax, %eax
cmpl $0xfffe, %ecx           # imm = 0xFFFE
je 0x5e2f
cmpl $0xfffe, %ecx           # imm = 0xFFFE
je 0x5df8
movl %ecx, 0x30(%rsp,%rax,4)
movl (%r14,%rax,4), %ecx
incq %rax
jmp 0x5de3
xorl %ecx, %ecx
cmpq %rcx, %r15
je 0x5e0f
movl 0x10(%rsp,%rcx,4), %edx
movl %edx, 0x30(%rsp,%rax,4)
incq %rcx
incq %rax
jmp 0x5dfa
movl %eax, %eax
movl $0xfffe, 0x30(%rsp,%rax,4) # imm = 0xFFFE
movq %rbx, %rdi
callq 0x2d7d
movb %al, 0x9(%rsp,%r15)
incq %r15
addq $0x4, %r14
jmp 0x5dd4
xorl %ecx, %ecx
cmpl $0xfffe, 0x10(%rsp,%rax,4) # imm = 0xFFFE
je 0x5e61
cmpb $0x0, 0x9(%rsp,%rax)
je 0x5e5c
movq 0x50(%rsp,%rax,8), %rdx
testq %rcx, %rcx
je 0x5e59
movq 0x8(%rdx), %rsi
cmpq 0x8(%rcx), %rsi
jl 0x5e59
movq %rcx, %rdx
movq %rdx, %rcx
incq %rax
jmp 0x5e31
movq 0x20(%rcx), %rax
movq 0x28(%rax), %rax
movq 0x20(%rax), %rax
movq 0x28(%rax), %rax
movq 0x20(%rax), %rax
cmpw $0x246, 0x14(%rax)      # imm = 0x246
jne 0x5e6d
addq $0x90, %rsp
popq %rbx
popq %r14
popq %r15
retq