// File: /workspace/github_c_makefile_star2_O2/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 %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, 0x2(%rdi)       # imm = 0x246
je 0xadf5
xorl %ecx, %ecx
cmpq $0x7, %rcx
je 0xae34
andq $0x0, 0x50(%rsp,%rcx,8)
movl $0xfffe, 0x10(%rsp,%rcx,4) # imm = 0xFFFE
movb $0x0, 0x9(%rsp,%rcx)
incq %rcx
jmp 0xae16
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, 0x2(%rdx)       # imm = 0x246
je 0xae3e
movl %ecx, 0x10(%rsp)
pushq $0x1
popq %rcx
andq $0x0, 0x50(%rsp,%rcx,8)
movq 0x28(%rdx), %rdx
movq 0x18(%rdx), %rdx
cmpw $0x246, 0x2(%rdx)       # imm = 0x246
je 0xae83
andl $0x0, 0x10(%rsp,%rcx,4)
incq %rcx
jmp 0xae63
movabsq $0x100000000, %rsi      # imm = 0x100000000
movslq %ecx, %rdi
cmpq %rax, %rdx
je 0xaf13
movq %rdx, 0x50(%rsp,%rdi,8)
xorl %r8d, %r8d
movq %rdx, %r9
movq 0x18(%rdx), %rdx
movq 0x28(%rdx), %rdx
movq 0x18(%rdx), %rdx
movq 0x28(%rdx), %rdx
movq 0x18(%rdx), %rdx
incl %r8d
cmpw $0x246, 0x2(%rdx)       # imm = 0x246
je 0xae9d
shlq $0x20, %rcx
addq %rsi, %rcx
movq %rcx, %r10
sarq $0x1d, %rcx
andq $0x0, 0x50(%rsp,%rcx)
movl %r8d, 0x10(%rsp,%rdi,4)
sarq $0x20, %r10
movq 0x18(%r9), %rcx
movq 0x28(%rcx), %rcx
movq 0x18(%rcx), %rcx
movq 0x28(%rcx), %rcx
movq 0x18(%rcx), %rdx
movq %r10, %rcx
movq 0x28(%rdx), %rdx
movq 0x18(%rdx), %rdx
cmpw $0x246, 0x2(%rdx)       # imm = 0x246
je 0xae8d
andl $0x0, 0x10(%rsp,%rcx,4)
andq $0x0, 0x58(%rsp,%rcx,8)
incq %rcx
jmp 0xaef3
movl $0xfffe, 0x10(%rsp,%rdi,4) # imm = 0xFFFE
andq $0x0, 0x50(%rsp,%rdi,8)
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 0xaf97
cmpl $0xfffe, %ecx           # imm = 0xFFFE
je 0xaf60
movl %ecx, 0x30(%rsp,%rax,4)
movl (%r14,%rax,4), %ecx
incq %rax
jmp 0xaf4b
xorl %ecx, %ecx
cmpq %rcx, %r15
je 0xaf77
movl 0x10(%rsp,%rcx,4), %edx
movl %edx, 0x30(%rsp,%rax,4)
incq %rcx
incq %rax
jmp 0xaf62
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 0xaf3c
xorl %ecx, %ecx
cmpl $0xfffe, 0x10(%rsp,%rax,4) # imm = 0xFFFE
je 0xafc7
cmpb $0x0, 0x9(%rsp,%rax)
je 0xafc2
movq 0x50(%rsp,%rax,8), %rdx
testq %rcx, %rcx
je 0xafbf
movzwl (%rdx), %esi
cmpw (%rcx), %si
jb 0xafbf
movq %rcx, %rdx
movq %rdx, %rcx
incq %rax
jmp 0xaf99
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 0xafd3
addq $0x90, %rsp
popq %rbx
popq %r14
popq %r15
retq