// File: /workspace/github_c_makefile_star2_O1/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 0xcf67
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 0xcfab
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, 0x2(%rdx)       # imm = 0x246
je 0xcfc6
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 0xd02f
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 0xd00b
cmpq %rax, %rdx
je 0xd0db
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 0xd047
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 0xd0d2
movslq %ecx, %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 0xd0ad
addl %edi, %ecx
cmpq %rax, %rdx
jne 0xd03d
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 0x486e
movb %al, 0x8(%rsp)
cmpl %ebp, (%rbx)
je 0xd195
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 0xd144
xorl %r14d, %r14d
movl %eax, 0x70(%rsp,%r14,4)
movl (%r12,%r14,4), %eax
incq %r14
cmpl $0xfffe, %eax           # imm = 0xFFFE
jne 0xd131
testq %r13, %r13
je 0xd16c
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 0xd11c
xorl %eax, %eax
xorl %ecx, %ecx
cmpb $0x0, 0x8(%rsp,%rax)
je 0xd1b7
testq %rcx, %rcx
je 0xd1b2
movq 0x30(%rsp,%rax,8), %rdx
movzwl (%rdx), %edx
cmpw (%rcx), %dx
jae 0xd1b7
movq 0x30(%rsp,%rax,8), %rcx
cmpl $0xfffe, 0x14(%rsp,%rax,4) # imm = 0xFFFE
leaq 0x1(%rax), %rax
jne 0xd199
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 0xd1d1
addq $0x98, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq