// File: /workspace/github_c_makefile_star2_O1/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 %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, 0x14(%rdi)      # imm = 0x246
je 0x7b59
xorps %xmm0, %xmm0
movaps %xmm0, 0x50(%rsp)
movaps %xmm0, 0x40(%rsp)
movaps %xmm0, 0x30(%rsp)
movq $0x0, 0x60(%rsp)
xorl %ecx, %ecx
movl %ecx, 0x8(%rsp)
movl %ecx, 0xb(%rsp)
movl $0xfffe, 0x10(%rsp,%rcx,4) # imm = 0xFFFE
incq %rcx
cmpq $0x7, %rcx
jne 0x7b9d
movq %rax, 0x30(%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 0x7bb8
movl %ecx, 0x10(%rsp)
movq $0x0, 0x38(%rsp)
movq 0x28(%rdx), %rcx
movq 0x18(%rcx), %rdx
movl $0x1, %ecx
cmpw $0x246, 0x14(%rdx)      # imm = 0x246
je 0x7c21
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, 0x14(%rdx)      # imm = 0x246
jne 0x7bfd
cmpq %rax, %rdx
je 0x7cd1
leaq 0x38(%rsp), %rdi
movslq %ecx, %r8
movq %rdx, 0x30(%rsp,%r8,8)
xorl %ecx, %ecx
movq %rdx, %r9
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 0x7c39
movl %ecx, 0x10(%rsp,%r8,4)
leal 0x1(%r8), %ecx
movq $0x0, 0x38(%rsp,%r8,8)
movq 0x18(%r9), %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, 0x14(%rdx)      # imm = 0x246
je 0x7cc8
movslq %ecx, %r8
leaq (%rsp,%r8,4), %r9
addq $0x10, %r9
leaq (%rdi,%r8,8), %r10
xorl %r8d, %r8d
movl $0x0, (%r9,%r8,4)
movq $0x0, (%r10,%r8,8)
movq 0x28(%rdx), %rdx
movq 0x18(%rdx), %rdx
incq %r8
cmpw $0x246, 0x14(%rdx)      # imm = 0x246
jne 0x7ca2
addl %r8d, %ecx
cmpq %rax, %rdx
jne 0x7c2f
movslq %ecx, %rax
movl $0xfffe, %ebp           # imm = 0xFFFE
movl %ebp, 0x10(%rsp,%rax,4)
movq $0x0, 0x30(%rsp,%rax,8)
movl $0x6, %ecx
subl %eax, %ecx
movl %ecx, (%rsi)
leaq 0x10(%rsp), %rbx
movq %rbx, %rdi
callq 0x486e
movb %al, 0x8(%rsp)
cmpl %ebp, (%rbx)
je 0x7d94
movl $0xffffffff, %r15d      # imm = 0xFFFFFFFF
leaq 0x14(%rsp), %r12
xorl %r13d, %r13d
leaq 0x70(%rsp), %rbx
movl 0x10(%rsp,%r13,4), %eax
movl $0x0, %r14d
cmpl $0xfffe, %eax           # imm = 0xFFFE
je 0x7d43
xorl %r14d, %r14d
movl %eax, 0x70(%rsp,%r14,4)
movl (%r12,%r14,4), %eax
incq %r14
cmpl $0xfffe, %eax           # imm = 0xFFFE
jne 0x7d30
testq %r13, %r13
je 0x7d6b
leaq (,%r13,4), %rdx
movl %r14d, %eax
leaq (%rsp,%rax,4), %rdi
addq $0x70, %rdi
leaq 0x10(%rsp), %rsi
callq 0x10d0
addl %r15d, %r14d
incl %r14d
movl %r14d, %eax
movl %ebp, 0x70(%rsp,%rax,4)
movq %rbx, %rdi
callq 0x486e
movb %al, 0x8(%rsp,%r13)
leaq 0x1(%r13), %rax
incl %r15d
addq $0x4, %r12
cmpl %ebp, 0x14(%rsp,%r13,4)
movq %rax, %r13
jne 0x7d1b
xorl %eax, %eax
xorl %ecx, %ecx
cmpb $0x0, 0x8(%rsp,%rax)
je 0x7db8
testq %rcx, %rcx
je 0x7db3
movq 0x30(%rsp,%rax,8), %rdx
movq 0x8(%rdx), %rdx
cmpq 0x8(%rcx), %rdx
jge 0x7db8
movq 0x30(%rsp,%rax,8), %rcx
cmpl $0xfffe, 0x14(%rsp,%rax,4) # imm = 0xFFFE
leaq 0x1(%rax), %rax
jne 0x7d98
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 0x7dd2
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq