// File: /workspace/github_c_makefile_star2_O1/mishun[P]plantri/fullgen.c
// Function: reko_bb_code
void reko_bb_code(PLANMAP map, KNOTENTYP *code, KNOTENTYP *spiegelcode, int laenge, 
		  KANTE *start, KANTE *ministart[], KANTE *spiegelministart[], int *patchknz)
{
int i, j, stelle, zaehler, knotenzahl, flaechennumber, schichtenzaehler, verschiebung, merkeknoten;
/* zaehler zaehlt die Flaechengroesse, knotenzahl die zahl der restlichen knoten */
int laufzaehler;
KANTE *run, *merke, *run2, *merke_run, *mstart;
KNOTENTYP testcode[9];
int mstartzaehler, test, k, laenge_2;
BOOL mark[N+1];


if (start->mininame != aussen) { fprintf(stderr,"Reko_BB_code must start at external edge !\n"); 
			     exit(29); }
for (i=0; i<8; i++) { code[i]=spiegelcode[i]=unbelegt; testcode[i]=0; }

mstartzaehler=0;
for (i=0; i<7; i++) ministart[i]=spiegelministart[i]=nil;

for (i=1; i<=map[0][0].name; i++) mark[i]=0;
mark[start->ursprung]=1; *patchknz=1;

zaehle_knoten(map,start->ursprung,mark,patchknz);

laenge_2 = laenge/2;
run=start; knotenzahl=*patchknz;

verschiebung=schichtenzaehler=0;

while (!verschiebung)
  {for (i=1, run2=run->prev; (i<=laenge_2) && !verschiebung; i++, run2=run2->prev->invers->next->invers)
     /* muss bei 1 starten und nachher korrigiert werden, um den Abbruch bei 0 zu gewaehrleisten */
     { if (checksize(run2) == 5) { run=run2->next; verschiebung=i; } }
   if (!verschiebung) { schichtenzaehler++;
			knotenzahl -= laenge;
			run=run->prev->invers->next->invers;
			for (run2=run, i=0; i<laenge_2; i++, 
			     run2=run2->next->invers->next->invers->next)
			  { run2->dummy=infty; }
		      }
 } /* ende while */
code[0]=schichtenzaehler; code[1]=0; /* verschiebung wird nicht betrachtet */ stelle=2; 
merkeknoten=knotenzahl;
laufzaehler=1;
/* Jetzt den minimalen Code ausrechnen: */
for ( run2=run->prev; verschiebung<=laenge_2; verschiebung++, run2=run2->prev->invers->next->invers)
  if (checksize(run2)==5)
    { merke_run=run2->next; 
      laufzaehler++;
      run=run2->next;
      stelle=2; knotenzahl=merkeknoten;
      flaechennumber=0;
      while (stelle<8)
	{ 
	  flaechennumber++;
	  zaehler=2;
	  while (run->prev->invers->prev->dummy>=laufzaehler) 
	    run=run->prev->invers->prev; /* sicherstellen, dass davor
					    keine aussenkanten sind */
	  run->prev->invers->dummy=laufzaehler; run->next->invers->dummy=laufzaehler;
	  run=run->next->invers->next; knotenzahl--;
	  while (run->dummy>=laufzaehler)
	    { zaehler++; knotenzahl--; run->prev->invers->dummy=laufzaehler; 
	      run->next->invers->dummy=laufzaehler;
	      run=run->next->invers->next; }
	  merke=run->next;
	  run=run->prev;
	  while (merke->dummy<laufzaehler)
	    { zaehler++; merke=merke->invers->prev; }
	  if (zaehler==5) { testcode[stelle]=flaechennumber; stelle++; }
	  else if (zaehler!=6) { fprintf(stderr,"ERROR in REKO_BB_CODE: No 5- or 6-Gon !\n"); exit(30); }
	  if (knotenzahl==5) { testcode[stelle]=flaechennumber+1; stelle++; }
	} /* ende while */
      if ((test=codecmp_kn(code+2,testcode+2,6))>=0) 
	{ if (test>0) { for (stelle=2; stelle<8; stelle++) code[stelle]=testcode[stelle];
			for (k=0; k<mstartzaehler; k++) ministart[k]=nil;
		        mstartzaehler=0;}
	  mstart=merke_run;
	  for (k=0; k<schichtenzaehler; k++) mstart = mstart->invers->prev->invers->next;
	  ministart[mstartzaehler]=mstart->prev->invers->next;
	  mstartzaehler++;
	}
    } /* ende checksize==5 */



/* Jetzt den Spiegelcode */

for (i=1; i<=map[0][0].name; i++) 
  if (mark[i]) 
    for (j=0; j<3; j++) 
      { if (map[i][j].mininame==aussen) map[i][j].dummy=infty;
        else map[i][j].dummy=0; }

run=start; knotenzahl=*patchknz;

verschiebung=schichtenzaehler=mstartzaehler=0;

while (!verschiebung)
  {for (i=1, run2=run->prev; (i<=laenge_2) && !verschiebung; i++, run2=run2->invers->prev->invers->next)
     /* muss bei 1 starten und nachher korrigiert werden, um den Abbruch bei 0 zu gewaehrleisten */
     { if (checksize(run2) == 5) { run=run2->next; verschiebung=i; } }
   if (!verschiebung) { schichtenzaehler++;
			knotenzahl -= laenge;
			run=run->next->invers->prev->invers;
			for (run2=run, i=0; i<laenge_2; i++, 
			     run2=run2->prev->invers->prev->invers->prev)
			  { run2->dummy=infty; }
		      }
 } /* ende while */
spiegelcode[0]=schichtenzaehler; spiegelcode[1]=0; /* verschiebung wird nicht betrachtet */ stelle=2; 
merkeknoten=knotenzahl;
laufzaehler=1;
/* Jetzt den minimalen Code ausrechnen: */
for ( run2=run->prev; verschiebung<=laenge_2; verschiebung++, run2=run2->invers->prev->invers->next)
  if (checksize(run2)==5)
    { merke_run=run2->next; 
      laufzaehler++;
      run=run2->next;
      stelle=2; knotenzahl=merkeknoten;
      flaechennumber=0;
      while (stelle<8)
	{ flaechennumber++;
	  zaehler=2;
	  while (run->next->invers->next->dummy>=laufzaehler) 
	    run=run->next->invers->next; /* sicherstellen, dass davor
					    keine aussenkanten sind */
	  run->next->invers->dummy=laufzaehler; run->prev->invers->dummy=laufzaehler;
	  run=run->prev->invers->prev; knotenzahl--;
	  while (run->dummy>=laufzaehler)
	    { zaehler++; knotenzahl--; run->next->invers->dummy=laufzaehler; 
	      run->prev->invers->dummy=laufzaehler;
	      run=run->prev->invers->prev; }
	  merke=run->prev;
	  run=run->next;
	  while (merke->dummy<laufzaehler)
	    { zaehler++; merke=merke->invers->next; }
	  if (zaehler==5) { testcode[stelle]=flaechennumber; stelle++; }
	  else if (zaehler!=6) { fprintf(stderr,"ERROR in REKO_BB_CODE(2):  No 5- or 6-Gon !\n"); exit(31); }
	  if (knotenzahl==5) { testcode[stelle]=flaechennumber+1; stelle++; }
	} /* ende while */
      if ((test=codecmp_kn(spiegelcode+2,testcode+2,6))>=0) 
	{ if (test>0) { for (stelle=2; stelle<8; stelle++) spiegelcode[stelle]=testcode[stelle];
			for (k=0; k<mstartzaehler; k++) spiegelministart[k]=nil;
		        mstartzaehler=0;}
	  mstart=merke_run;
	  for (k=0; k<schichtenzaehler; k++) mstart = mstart->invers->next->invers->prev;
	  spiegelministart[mstartzaehler]=mstart->next->invers->prev;
	  mstartzaehler++;
	}
    } /* ende checksize==5 */

return;
}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x2b8, %rsp            # imm = 0x2B8
cmpw $0x246, 0x14(%r8)       # imm = 0x246
jne 0x7352
movq %r8, %r14
movl %ecx, %r15d
movq %rdi, %r12
movq 0x2f8(%rsp), %r13
movq 0x2f0(%rsp), %rdi
xorps %xmm0, %xmm0
movaps %xmm0, 0x20(%rsp)
xorl %eax, %eax
movw $0xff, %cx
movw %cx, (%rdx,%rax,2)
movw %cx, (%rsi,%rax,2)
incq %rax
cmpq $0x8, %rax
jne 0x6cad
movq %rsi, 0x48(%rsp)
movq %rdx, 0x40(%rsp)
xorl %eax, %eax
xorl %ecx, %ecx
movq %rax, (%rdi,%rcx,8)
movq %rax, (%r9,%rcx,8)
incq %rcx
cmpq $0x7, %rcx
jne 0x6ccc
movq %r9, 0x58(%rsp)
movzwl 0x2(%r12), %edx
testq %rdx, %rdx
je 0x6cf9
leaq 0x71(%rsp), %rdi
xorl %esi, %esi
callq 0x1080
movabsq $0x7fffffffffffffff, %rbx # imm = 0x7FFFFFFFFFFFFFFF
movzwl (%r14), %esi
movb $0x1, 0x70(%rsp,%rsi)
movl $0x1, (%r13)
leaq 0x70(%rsp), %rdx
movq %r12, %rdi
movq %r13, %rcx
callq 0x6bdd
movl %r15d, %ebp
shrl $0x1f, %ebp
addl %r15d, %ebp
sarl %ebp
movl (%r13), %r8d
xorl %r13d, %r13d
movq %r14, 0x68(%rsp)
xorl %r9d, %r9d
movl %r8d, %r10d
movb $0x1, %dl
cmpl $0x2, %r15d
jl 0x6d98
leaq 0x18(%r14), %rsi
movl $0x1, %ecx
movq (%rsi), %rsi
movl $0x5, %edx
movq %rsi, %rdi
movq 0x28(%rdi), %rdi
movq 0x20(%rdi), %rdi
decl %edx
cmpq %rsi, %rdi
jne 0x6d5d
testl %edx, %edx
jne 0x6d77
movq 0x20(%rsi), %r14
movl %ecx, %r13d
testl %r13d, %r13d
sete %dl
cmpl %ebp, %ecx
jge 0x6d98
incl %ecx
movq 0x18(%rsi), %rsi
movq 0x28(%rsi), %rsi
movq 0x20(%rsi), %rsi
addq $0x28, %rsi
testl %r13d, %r13d
je 0x6d52
testb %dl, %dl
je 0x6dd9
incl %r9d
subl %r15d, %r10d
movq 0x18(%r14), %rax
movq 0x28(%rax), %rax
movq 0x20(%rax), %rax
movq 0x28(%rax), %r14
cmpl $0x2, %r15d
jl 0x6dd9
movl %ebp, %ecx
movq %r14, %rdx
movq %rbx, 0x8(%rdx)
movq 0x20(%rdx), %rdx
movq 0x28(%rdx), %rdx
movq 0x20(%rdx), %rdx
movq 0x28(%rdx), %rdx
movq 0x20(%rdx), %rdx
decl %ecx
jne 0x6dbd
testl %r13d, %r13d
je 0x6d41
movl %r10d, 0x54(%rsp)
movq 0x48(%rsp), %rcx
movl %r9d, 0x50(%rsp)
movw %r9w, (%rcx)
movw $0x0, 0x2(%rcx)
cmpl %ebp, %r13d
movq 0x40(%rsp), %r10
movq 0x2f0(%rsp), %r11
jg 0x703c
addq $0x18, %r14
movq 0x48(%rsp), %rcx
addq $0x4, %rcx
movq %rcx, 0x60(%rsp)
movl $0x1, 0x8(%rsp)
movq $0x0, 0x10(%rsp)
movl %r8d, 0xc(%rsp)
movl %r15d, 0x1c(%rsp)
movq (%r14), %r14
movl $0x5, %eax
movq %r14, %rcx
movq 0x28(%rcx), %rcx
movq 0x20(%rcx), %rcx
decl %eax
cmpq %r14, %rcx
jne 0x6e49
testl %eax, %eax
jne 0x701c
movq 0x20(%r14), %r15
movl 0x8(%rsp), %eax
incl %eax
movl %eax, 0x8(%rsp)
cltq
movl $0x2, %ecx
xorl %r9d, %r9d
movq %r15, %rdi
movl 0x54(%rsp), %edx
movl %r9d, %esi
movq %rdi, %r8
movq 0x18(%rdi), %rdi
movq 0x28(%rdi), %r9
movq 0x18(%r9), %rdi
cmpq %rax, 0x8(%rdi)
jge 0x6e82
movq %rax, 0x8(%r9)
movq 0x20(%r8), %rdi
movq 0x28(%rdi), %rdi
movq %rax, 0x8(%rdi)
movq 0x20(%rdi), %r9
cmpq %rax, 0x8(%r9)
jge 0x6ebb
decl %edx
movl $0x2, %r8d
jmp 0x6eec
movl $0x1, %r8d
movq 0x18(%r9), %rdi
movq 0x28(%rdi), %rdi
movq %rax, 0x8(%rdi)
movq 0x20(%r9), %rdi
movq 0x28(%rdi), %rdi
movq %rax, 0x8(%rdi)
movq 0x20(%rdi), %r9
incl %r8d
cmpq %rax, 0x8(%r9)
jge 0x6ec1
subl %r8d, %edx
incl %r8d
movq 0x18(%r9), %rdi
movq 0x20(%r9), %r9
cmpq %rax, 0x8(%r9)
jge 0x6f07
incl %r8d
movq 0x28(%r9), %r9
movq 0x18(%r9), %r9
jmp 0x6ef4
leal 0x1(%rsi), %r9d
cmpl $0x6, %r8d
je 0x6f26
cmpl $0x5, %r8d
jne 0x7348
movslq %ecx, %rcx
movw %r9w, 0x20(%rsp,%rcx,2)
incl %ecx
cmpl $0x5, %edx
jne 0x6f38
addl $0x2, %esi
movslq %ecx, %rcx
movw %si, 0x20(%rsp,%rcx,2)
incl %ecx
cmpl $0x8, %ecx
jl 0x6e7f
movq 0x60(%rsp), %rax
movzwl (%rax), %eax
movzwl 0x24(%rsp), %ecx
cmpw %cx, %ax
movq 0x48(%rsp), %rdi
jne 0x6f75
xorl %edx, %edx
movzwl 0x6(%rdi,%rdx,2), %eax
movzwl 0x26(%rsp,%rdx,2), %ecx
cmpw %cx, %ax
jne 0x6f75
leaq 0x1(%rdx), %rsi
cmpl $0x4, %edx
movq %rsi, %rdx
jne 0x6f5a
cmpw %cx, %ax
jb 0x7012
je 0x6fd2
leaq 0x24(%rsp), %rdx
movl 0x8(%rdx), %eax
movq 0x60(%rsp), %rcx
movl %eax, 0x8(%rcx)
movq (%rdx), %rax
movq %rax, (%rcx)
movq 0x10(%rsp), %rax
testl %eax, %eax
jle 0x6fc9
movl %eax, %edx
shlq $0x3, %rdx
movq $0x0, 0x10(%rsp)
movq 0x58(%rsp), %rdi
xorl %esi, %esi
callq 0x1080
movq 0x2f0(%rsp), %r11
movq 0x40(%rsp), %r10
jmp 0x6fd2
movq $0x0, 0x10(%rsp)
movl 0x50(%rsp), %eax
testl %eax, %eax
jle 0x6fee
movq 0x28(%r15), %rcx
movq 0x18(%rcx), %rcx
movq 0x28(%rcx), %rcx
movq 0x20(%rcx), %r15
decl %eax
jne 0x6fda
movq 0x18(%r15), %rax
movq 0x28(%rax), %rax
movq 0x20(%rax), %rax
movq 0x10(%rsp), %rdx
movslq %edx, %rdx
movq 0x58(%rsp), %rcx
movq %rax, (%rcx,%rdx,8)
incl %edx
movq %rdx, 0x10(%rsp)
movl 0xc(%rsp), %r8d
movl 0x1c(%rsp), %r15d
leal 0x1(%r13), %ecx
movq 0x18(%r14), %rax
movq 0x28(%rax), %rax
movq 0x20(%rax), %r14
addq $0x28, %r14
cmpl %ebp, %r13d
movl %ecx, %r13d
jne 0x6e3e
movzwl 0x2(%r12), %eax
testq %rax, %rax
movq 0x68(%rsp), %rdi
je 0x7096
addq $0xa4, %r12
movl $0x1, %ecx
cmpb $0x0, 0x70(%rsp,%rcx)
je 0x7083
xorl %edx, %edx
cmpw $0x246, (%r12,%rdx)     # imm = 0x246
movl $0x0, %esi
cmoveq %rbx, %rsi
movq %rsi, -0xc(%r12,%rdx)
addq $0x30, %rdx
cmpq $0x90, %rdx
jne 0x7061
leaq 0x1(%rcx), %rdx
addq $0x90, %r12
cmpq %rax, %rcx
movq %rdx, %rcx
jne 0x7058
xorl %r12d, %r12d
xorl %r14d, %r14d
movb $0x1, %cl
cmpl $0x2, %r15d
jl 0x70f3
leaq 0x18(%rdi), %rdx
movl $0x1, %eax
movq (%rdx), %rdx
movl $0x5, %ecx
movq %rdx, %rsi
movq 0x28(%rsi), %rsi
movq 0x20(%rsi), %rsi
decl %ecx
cmpq %rdx, %rsi
jne 0x70b8
testl %ecx, %ecx
jne 0x70d2
movq 0x20(%rdx), %rdi
movl %eax, %r12d
testl %r12d, %r12d
sete %cl
cmpl %ebp, %eax
jge 0x70f3
incl %eax
movq 0x28(%rdx), %rdx
movq 0x18(%rdx), %rdx
movq 0x28(%rdx), %rdx
addq $0x20, %rdx
testl %r12d, %r12d
je 0x70ad
testb %cl, %cl
je 0x7134
incl %r14d
subl %r15d, %r8d
movq 0x20(%rdi), %rax
movq 0x28(%rax), %rax
movq 0x18(%rax), %rax
movq 0x28(%rax), %rdi
cmpl $0x2, %r15d
jl 0x7134
movl %ebp, %eax
movq %rdi, %rcx
movq %rbx, 0x8(%rcx)
movq 0x18(%rcx), %rcx
movq 0x28(%rcx), %rcx
movq 0x18(%rcx), %rcx
movq 0x28(%rcx), %rcx
movq 0x18(%rcx), %rcx
decl %eax
jne 0x7118
testl %r12d, %r12d
je 0x709c
movl %r8d, 0xc(%rsp)
movw %r14w, (%r10)
movw $0x0, 0x2(%r10)
cmpl %ebp, %r12d
jg 0x7336
addq $0x18, %rdi
leaq 0x4(%r10), %rax
movq %rax, 0x10(%rsp)
movl $0x1, 0x8(%rsp)
xorl %ebx, %ebx
movq (%rdi), %r15
movl $0x5, %eax
movq %r15, %rcx
movq 0x28(%rcx), %rcx
movq 0x20(%rcx), %rcx
decl %eax
cmpq %r15, %rcx
jne 0x7178
testl %eax, %eax
jne 0x7315
movq 0x20(%r15), %r13
movl 0x8(%rsp), %eax
incl %eax
movl %eax, 0x8(%rsp)
cltq
movl $0x2, %ecx
xorl %r9d, %r9d
movq %r13, %rdi
movl 0xc(%rsp), %edx
movl %r9d, %esi
movq %rdi, %r8
movq 0x20(%rdi), %rdi
movq 0x28(%rdi), %r9
movq 0x20(%r9), %rdi
cmpq %rax, 0x8(%rdi)
jge 0x71b1
movq %rax, 0x8(%r9)
movq 0x18(%r8), %rdi
movq 0x28(%rdi), %rdi
movq %rax, 0x8(%rdi)
movq 0x18(%rdi), %rdi
cmpq %rax, 0x8(%rdi)
jge 0x71ea
decl %edx
movl $0x2, %r8d
jmp 0x721b
movl $0x1, %r8d
movq 0x20(%rdi), %r9
movq 0x28(%r9), %r9
movq %rax, 0x8(%r9)
movq 0x18(%rdi), %rdi
movq 0x28(%rdi), %rdi
movq %rax, 0x8(%rdi)
movq 0x18(%rdi), %rdi
incl %r8d
cmpq %rax, 0x8(%rdi)
jge 0x71f0
subl %r8d, %edx
incl %r8d
movq 0x18(%rdi), %r9
movq 0x20(%rdi), %rdi
cmpq %rax, 0x8(%r9)
jge 0x7236
incl %r8d
movq 0x28(%r9), %r9
movq 0x20(%r9), %r9
jmp 0x7223
leal 0x1(%rsi), %r9d
cmpl $0x6, %r8d
je 0x7255
cmpl $0x5, %r8d
jne 0x734d
movslq %ecx, %rcx
movw %r9w, 0x20(%rsp,%rcx,2)
incl %ecx
cmpl $0x5, %edx
jne 0x7267
addl $0x2, %esi
movslq %ecx, %rcx
movw %si, 0x20(%rsp,%rcx,2)
incl %ecx
cmpl $0x8, %ecx
jl 0x71ae
movq 0x10(%rsp), %rax
movzwl (%rax), %eax
movzwl 0x24(%rsp), %ecx
cmpw %cx, %ax
jne 0x72a0
xorl %edx, %edx
movzwl 0x6(%r10,%rdx,2), %eax
movzwl 0x26(%rsp,%rdx,2), %ecx
cmpw %cx, %ax
jne 0x72a0
leaq 0x1(%rdx), %rsi
cmpl $0x4, %edx
movq %rsi, %rdx
jne 0x7284
cmpw %cx, %ax
jb 0x7315
je 0x72e4
leaq 0x24(%rsp), %rdx
movl 0x8(%rdx), %eax
movq 0x10(%rsp), %rcx
movl %eax, 0x8(%rcx)
movq (%rdx), %rax
movq %rax, (%rcx)
testl %ebx, %ebx
jle 0x72e2
movl %ebx, %edx
shlq $0x3, %rdx
xorl %ebx, %ebx
movq %r11, %rdi
xorl %esi, %esi
callq 0x1080
movq 0x2f0(%rsp), %r11
movq 0x40(%rsp), %r10
jmp 0x72e4
xorl %ebx, %ebx
testl %r14d, %r14d
jle 0x7300
movl %r14d, %eax
movq 0x28(%r13), %rcx
movq 0x20(%rcx), %rcx
movq 0x28(%rcx), %rcx
movq 0x18(%rcx), %r13
decl %eax
jne 0x72ec
movq 0x20(%r13), %rax
movq 0x28(%rax), %rax
movq 0x18(%rax), %rax
movslq %ebx, %rbx
movq %rax, (%r11,%rbx,8)
incl %ebx
leal 0x1(%r12), %eax
movq 0x28(%r15), %rcx
movq 0x18(%rcx), %rcx
movq 0x28(%rcx), %rdi
addq $0x20, %rdi
cmpl %ebp, %r12d
movl %eax, %r12d
jne 0x716d
addq $0x2b8, %rsp            # imm = 0x2B8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x1777
callq 0x179c
callq 0x1752