// File: /workspace/github_c_makefile_star2_O1/mishun[P]plantri/fullgen.c
// Function: get_spiralcode
BOOL get_spiralcode ( KANTE *edge, int minmark, FLAECHENTYP cmpcode[12],
		 int sixgons)

/* entwickelt den Spiralcode, bei dem die erste Flaeche links von edge
   liegt, die zweite rechts davon und die Entwicklung im Uhrzeigersinn
   geht. Entwickelt wird solange der Code besser ist als cmpcode. Das
   Resultat wird in cmpcode geschrieben, wenn es besser ist. Wenn ein 
   Code gefunden wird, der besser ist, als cmpcode, wird 1 zurueckgegeben, 
   sonst 0.  Die aufrufende Funktion muss sicherstellen, dass alle Kanten
   kante->dummy <= minmark erfuellen.
*/

{
int mark, i;
KANTE *nextedge;
BOOL kleiner=0;
FLAECHENTYP code[12], zaehler;
int fuenfecke=0, sechsecke=0; /* zaehler fuer die wirklich eingefuegten Flaechen */
int stelle;

mark=minmark+1;  

if (checksize_mark_return(edge, mark, &nextedge)==5)
                      {  code[0]=1; stelle=0; fuenfecke=1; } 
else { stelle= -1; sechsecke=1; }
if (checksize_mark_return_right( edge, mark, &nextedge)==5)
    { stelle++; code[stelle]=2; fuenfecke++; } else sechsecke++;

for (i=0; (i<=stelle) && (!kleiner); i++)
  { if (code[i]>cmpcode[i]) return(0);
    if (code[i]<cmpcode[i]) kleiner=1; }

zaehler=3;

while (nextedge != nil)
  { if (checksize_mark_return_right(nextedge, mark, &nextedge)==5)
                       { fuenfecke++;
			 stelle++; code[stelle]=zaehler; 
		         if (!kleiner)
			    { if (zaehler>cmpcode[stelle]) { return(0); }
			      if (zaehler<cmpcode[stelle]) kleiner=1;
			    }
		       }
    else sechsecke++;
    zaehler++;
  }

if ((fuenfecke<12) || (sechsecke < sixgons)) return(0);

for (i=0; i<12; i++) cmpcode[i]=code[i];
return(1);
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x28, %rsp
movl %ecx, 0x10(%rsp)
movq %rdx, %rbx
movl %esi, %r14d
movq %rdi, %r15
incl %r14d
leaq 0x8(%rsp), %rdx
movl %r14d, %esi
callq 0x2bdc
cmpl $0x5, %eax
jne 0x2cd4
movb $0x1, 0x14(%rsp)
xorl %r12d, %r12d
movl $0x1, %r13d
xorl %ebp, %ebp
jmp 0x2ce2
movl $0xffffffff, %ebp       # imm = 0xFFFFFFFF
movl $0x1, %r12d
xorl %r13d, %r13d
leaq 0x8(%rsp), %rdx
movq %r15, %rdi
movl %r14d, %esi
callq 0x2c37
cmpl $0x5, %eax
jne 0x2d03
incl %ebp
movb $0x2, 0x14(%rsp,%rbp)
incl %r13d
jmp 0x2d06
incl %r12d
testl %ebp, %ebp
js 0x2d3c
movl %ebp, %eax
xorl %ecx, %ecx
movl $0x1, %edx
xorl %r15d, %r15d
movb (%rbx,%rcx), %sil
cmpb %sil, 0x14(%rsp,%rcx)
ja 0x2dbf
movzbl %r15b, %r15d
cmovbl %edx, %r15d
cmpq %rax, %rcx
jae 0x2d3f
incq %rcx
testb %r15b, %r15b
je 0x2d16
jmp 0x2d3f
xorl %r15d, %r15d
movq %rbx, 0x20(%rsp)
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
je 0x2d98
movb $0x3, %bl
movl %r14d, %esi
leaq 0x8(%rsp), %rdx
callq 0x2c37
cmpl $0x5, %eax
jne 0x2d79
incl %r13d
movslq %ebp, %rbp
movb %bl, 0x15(%rsp,%rbp)
incq %rbp
testb %r15b, %r15b
je 0x2d7e
movb $0x1, %r15b
jmp 0x2d8c
incl %r12d
jmp 0x2d8c
movq 0x20(%rsp), %rax
cmpb (%rax,%rbp), %bl
ja 0x2dbf
setb %r15b
incb %bl
movq 0x8(%rsp), %rdi
testq %rdi, %rdi
jne 0x2d50
xorl %eax, %eax
cmpl $0xc, %r13d
movq 0x20(%rsp), %rcx
jl 0x2dc1
cmpl 0x10(%rsp), %r12d
jl 0x2dc1
movl 0x1c(%rsp), %eax
movl %eax, 0x8(%rcx)
movq 0x14(%rsp), %rax
movq %rax, (%rcx)
movb $0x1, %al
jmp 0x2dc1
xorl %eax, %eax
addq $0x28, %rsp
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq