// File: /workspace/github_c_makefile_star2_O3/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 0x7d06
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 0x830f(%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, 0x14(%rdx)      # imm = 0x246
je 0x7d75
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 0x7dde
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 0x7dba
cmpq %rax, %rdx
je 0x7e8e
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 0x7df6
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 0x7e85
incq %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 0x7e5f
addl %r8d, %ecx
cmpq %rax, %rdx
jne 0x7dec
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 0x48b3
movb %al, 0x8(%rsp)
movl (%rbx), %eax
cmpl %ebp, %eax
je 0x7f41
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 0x7ee2
testq %r12, %r12
je 0x7f1d
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 0x7ed5
xorl %eax, %eax
xorl %ecx, %ecx
cmpb $0x0, 0x8(%rsp,%rax)
je 0x7f66
movq 0x30(%rsp,%rax,8), %rdx
testq %rcx, %rcx
je 0x7f63
movq 0x8(%rdx), %rsi
cmpq 0x8(%rcx), %rsi
jl 0x7f63
movq %rcx, %rdx
movq %rdx, %rcx
cmpl $0xfffe, 0x14(%rsp,%rax,4) # imm = 0xFFFE
leaq 0x1(%rax), %rax
jne 0x7f45
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 0x7f80
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq