// File: /workspace/github_c_makefile_star2_O2/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 $0x2a8, %rsp            # imm = 0x2A8
movq %r9, 0x10(%rsp)
movq %rdx, 0x48(%rsp)
movq %rsi, 0x18(%rsp)
movq %r8, 0x50(%rsp)
cmpw $0x246, 0x14(%r8)       # imm = 0x246
jne 0x564c
movl %ecx, %ebp
movq %rdi, %r13
movq 0x2e8(%rsp), %rbx
xorl %eax, %eax
movw $0xff, %cx
cmpq $0x8, %rax
je 0x5045
movq 0x48(%rsp), %rdx
movw %cx, (%rdx,%rax,2)
movq 0x18(%rsp), %rdx
movw %cx, (%rdx,%rax,2)
andw $0x0, 0x30(%rsp,%rax,2)
incq %rax
jmp 0x5022
xorl %eax, %eax
cmpq $0x7, %rax
je 0x5069
movq 0x2e0(%rsp), %rcx
andq $0x0, (%rcx,%rax,8)
movq 0x10(%rsp), %rcx
andq $0x0, (%rcx,%rax,8)
incq %rax
jmp 0x5047
movzwl 0x2(%r13), %eax
xorl %ecx, %ecx
cmpq %rcx, %rax
je 0x507f
movb $0x0, 0x61(%rsp,%rcx)
incq %rcx
jmp 0x5070
movq 0x50(%rsp), %r15
movzwl (%r15), %esi
movb $0x1, 0x60(%rsp,%rsi)
movl $0x1, (%rbx)
leaq 0x60(%rsp), %rdx
movq %r13, %rdi
movq %rbx, %rcx
callq 0x4f56
pushq $0x2
popq %rcx
movl %ebp, 0x28(%rsp)
movl %ebp, %eax
cltd
idivl %ecx
movl %eax, %ebp
movl (%rbx), %eax
movl $0x0, 0x8(%rsp)
testl %ebp, %ebp
movl $0x0, %ecx
cmovgl %ebp, %ecx
movl %ecx, 0x24(%rsp)
movl %eax, 0x2c(%rsp)
movl %eax, 0xc(%rsp)
xorl %r12d, %r12d
testl %r12d, %r12d
jne 0x517b
leaq 0x18(%r15), %rax
xorl %r12d, %r12d
pushq $0x1
popq %r14
testl %r12d, %r12d
jne 0x5121
cmpl %ebp, %r14d
jg 0x5121
movq (%rax), %rbx
movq %rbx, %rdi
callq 0x3424
xorl %r12d, %r12d
cmpl $0x5, %eax
jne 0x510c
movq 0x20(%rbx), %r15
movl %r14d, %r12d
incl %r14d
movq 0x18(%rbx), %rax
movq 0x28(%rax), %rax
movq 0x20(%rax), %rax
addq $0x28, %rax
jmp 0x50e8
testl %r12d, %r12d
jne 0x50d4
incl 0x8(%rsp)
movq 0x18(%r15), %rax
movq 0x28(%rax), %rax
movq 0x20(%rax), %rax
movq 0x28(%rax), %r15
movl 0x24(%rsp), %eax
movq %r15, %rcx
movabsq $0x7fffffffffffffff, %rdx # imm = 0x7FFFFFFFFFFFFFFF
subl $0x1, %eax
jb 0x516a
movq %rdx, 0x8(%rcx)
movq 0x20(%rcx), %rcx
movq 0x28(%rcx), %rcx
movq 0x20(%rcx), %rcx
movq 0x28(%rcx), %rcx
movq 0x20(%rcx), %rcx
jmp 0x514b
movl 0xc(%rsp), %eax
subl 0x28(%rsp), %eax
movl %eax, 0xc(%rsp)
jmp 0x50d4
movq 0x18(%rsp), %rax
movl 0x8(%rsp), %ecx
movw %cx, (%rax)
andw $0x0, 0x2(%rax)
addq $0x18, %r15
addq $0x4, %rax
movq %rax, 0x58(%rsp)
pushq $0x1
popq %rax
movl %eax, 0x4(%rsp)
xorl %ebx, %ebx
cmpl %ebp, %r12d
jg 0x532c
movq (%r15), %r15
movq %r15, %rdi
callq 0x3424
cmpl $0x5, %eax
jne 0x5314
movq %r15, %r14
movq 0x20(%r15), %r15
movl 0x4(%rsp), %eax
incl %eax
movl %eax, 0x4(%rsp)
cltq
xorl %r9d, %r9d
pushq $0x2
popq %r11
movl %r11d, %ecx
movl 0xc(%rsp), %edx
movq %r15, %rdi
cmpl $0x7, %ecx
jg 0x5286
movl %r9d, %esi
movq %rdi, %r9
movq 0x18(%rdi), %rdi
movq 0x28(%rdi), %r10
movq 0x18(%r10), %rdi
cmpq %rax, 0x8(%rdi)
jge 0x51ef
decl %edx
movl %r11d, %r8d
movq %rax, 0x8(%r10)
movq 0x20(%r9), %rdi
movq 0x28(%rdi), %rdi
movq %rax, 0x8(%rdi)
movq 0x20(%rdi), %r9
movq 0x18(%r9), %rdi
cmpq %rax, 0x8(%r9)
jl 0x5232
incl %r8d
movq 0x28(%rdi), %r10
decl %edx
jmp 0x5209
addq $0x20, %r9
movq (%r9), %r9
cmpq %rax, 0x8(%r9)
jge 0x524c
incl %r8d
movq 0x28(%r9), %r9
addq $0x18, %r9
jmp 0x5236
leal 0x1(%rsi), %r9d
cmpl $0x6, %r8d
je 0x526b
cmpl $0x5, %r8d
jne 0x5608
movslq %ecx, %r8
movw %r9w, 0x30(%rsp,%r8,2)
incl %ecx
cmpl $0x5, %edx
jne 0x51e3
addl $0x2, %esi
movslq %ecx, %rcx
movw %si, 0x30(%rsp,%rcx,2)
incl %ecx
jmp 0x51e3
movq 0x58(%rsp), %rdi
leaq 0x34(%rsp), %rsi
pushq $0x6
popq %rdx
callq 0x2337
testl %eax, %eax
js 0x5311
je 0x52dc
pushq $0x2
popq %rax
cmpq $0x8, %rax
je 0x52ba
movzwl 0x30(%rsp,%rax,2), %ecx
movq 0x18(%rsp), %rdx
movw %cx, (%rdx,%rax,2)
incq %rax
jmp 0x52a1
testl %ebx, %ebx
movl $0x0, %eax
cmovlel %eax, %ebx
xorl %eax, %eax
cmpq %rax, %rbx
je 0x52da
movq 0x10(%rsp), %rcx
andq $0x0, (%rcx,%rax,8)
incq %rax
jmp 0x52c6
xorl %ebx, %ebx
movl 0x8(%rsp), %eax
subl $0x1, %eax
jb 0x52f7
movq 0x28(%r15), %rcx
movq 0x18(%rcx), %rcx
movq 0x28(%rcx), %rcx
movq 0x20(%rcx), %r15
jmp 0x52e0
movq 0x18(%r15), %rax
movq 0x28(%rax), %rax
movq 0x20(%rax), %rax
movslq %ebx, %rbx
movq 0x10(%rsp), %rcx
movq %rax, (%rcx,%rbx,8)
incl %ebx
movq %r14, %r15
incl %r12d
movq 0x18(%r15), %rax
movq 0x28(%rax), %rax
movq 0x20(%rax), %r15
addq $0x28, %r15
jmp 0x51a2
movzwl 0x2(%r13), %eax
incq %rax
addq $0xa4, %r13
movabsq $0x7fffffffffffffff, %rsi # imm = 0x7FFFFFFFFFFFFFFF
pushq $0x1
popq %rdi
cmpq %rax, %rdi
je 0x5387
cmpb $0x0, 0x60(%rsp,%rdi)
je 0x537b
xorl %ecx, %ecx
cmpq $0x90, %rcx
je 0x537b
cmpw $0x246, (%r13,%rcx)     # imm = 0x246
movl $0x0, %edx
cmoveq %rsi, %rdx
movq %rdx, -0xc(%r13,%rcx)
addq $0x30, %rcx
jmp 0x5356
incq %rdi
addq $0x90, %r13
jmp 0x5348
movl $0x0, 0x4(%rsp)
pushq $0x1
popq %r14
xorl %r12d, %r12d
movq 0x50(%rsp), %r13
testl %r12d, %r12d
jne 0x543d
leaq 0x18(%r13), %rax
xorl %r12d, %r12d
movl %r14d, %r15d
testl %r12d, %r12d
jne 0x53e7
cmpl %ebp, %r15d
jg 0x53e7
movq (%rax), %rbx
movq %rbx, %rdi
callq 0x3424
xorl %r12d, %r12d
cmpl $0x5, %eax
jne 0x53d2
movq 0x20(%rbx), %r13
movl %r15d, %r12d
incl %r15d
movq 0x28(%rbx), %rax
movq 0x18(%rax), %rax
movq 0x28(%rax), %rax
addq $0x20, %rax
jmp 0x53ae
testl %r12d, %r12d
jne 0x539b
incl 0x4(%rsp)
movq 0x20(%r13), %rax
movq 0x28(%rax), %rax
movq 0x18(%rax), %rax
movq 0x28(%rax), %r13
movl 0x24(%rsp), %eax
movq %r13, %rcx
subl $0x1, %eax
jb 0x5430
movabsq $0x7fffffffffffffff, %rdx # imm = 0x7FFFFFFFFFFFFFFF
movq %rdx, 0x8(%rcx)
movq 0x18(%rcx), %rcx
movq 0x28(%rcx), %rcx
movq 0x18(%rcx), %rcx
movq 0x28(%rcx), %rcx
movq 0x18(%rcx), %rcx
jmp 0x5407
movl 0x28(%rsp), %eax
subl %eax, 0x2c(%rsp)
jmp 0x539b
movq 0x48(%rsp), %rax
movl 0x4(%rsp), %ecx
movw %cx, (%rax)
andw $0x0, 0x2(%rax)
addq $0x18, %r13
movq %r13, %rcx
addq $0x4, %rax
movq %rax, 0x18(%rsp)
pushq $0x1
popq %rax
movl %eax, 0x10(%rsp)
pushq $0x2
popq %r14
xorl %r13d, %r13d
cmpl %ebp, %r12d
jg 0x55f6
movq (%rcx), %rbx
movq %rbx, %rdi
callq 0x3424
cmpl $0x5, %eax
jne 0x55de
movq 0x20(%rbx), %r15
movl 0x10(%rsp), %eax
incl %eax
movl %eax, 0x10(%rsp)
cltq
xorl %r9d, %r9d
movl %r14d, %ecx
movl 0x2c(%rsp), %edx
movq %r15, %rdi
cmpl $0x7, %ecx
jg 0x5549
movl %r9d, %esi
movq %rdi, %r9
movq 0x20(%rdi), %rdi
movq 0x28(%rdi), %r10
movq 0x20(%r10), %rdi
cmpq %rax, 0x8(%rdi)
jge 0x54b2
decl %edx
movl %r14d, %r8d
movq %rax, 0x8(%r10)
movq 0x18(%r9), %rdi
movq 0x28(%rdi), %rdi
movq %rax, 0x8(%rdi)
movq 0x18(%rdi), %r9
movq 0x20(%r9), %rdi
cmpq %rax, 0x8(%r9)
jl 0x54f5
incl %r8d
movq 0x28(%rdi), %r10
decl %edx
jmp 0x54cc
addq $0x18, %r9
movq (%r9), %r9
cmpq %rax, 0x8(%r9)
jge 0x550f
incl %r8d
movq 0x28(%r9), %r9
addq $0x20, %r9
jmp 0x54f9
leal 0x1(%rsi), %r9d
cmpl $0x6, %r8d
je 0x552e
cmpl $0x5, %r8d
jne 0x5628
movslq %ecx, %r8
movw %r9w, 0x30(%rsp,%r8,2)
incl %ecx
cmpl $0x5, %edx
jne 0x54a6
addl $0x2, %esi
movslq %ecx, %rcx
movw %si, 0x30(%rsp,%rcx,2)
incl %ecx
jmp 0x54a6
movq 0x18(%rsp), %rdi
leaq 0x34(%rsp), %rsi
pushq $0x6
popq %rdx
callq 0x2337
testl %eax, %eax
js 0x55de
je 0x55a5
pushq $0x2
popq %rax
cmpq $0x8, %rax
je 0x557d
movzwl 0x30(%rsp,%rax,2), %ecx
movq 0x48(%rsp), %rdx
movw %cx, (%rdx,%rax,2)
incq %rax
jmp 0x5564
testl %r13d, %r13d
movl $0x0, %eax
cmovlel %eax, %r13d
xorl %eax, %eax
cmpq %rax, %r13
je 0x55a2
movq 0x2e0(%rsp), %rcx
andq $0x0, (%rcx,%rax,8)
incq %rax
jmp 0x558b
xorl %r13d, %r13d
movl 0x4(%rsp), %eax
subl $0x1, %eax
jb 0x55c0
movq 0x28(%r15), %rcx
movq 0x20(%rcx), %rcx
movq 0x28(%rcx), %rcx
movq 0x18(%rcx), %r15
jmp 0x55a9
movq 0x20(%r15), %rax
movq 0x28(%rax), %rax
movq 0x18(%rax), %rax
movslq %r13d, %r13
movq 0x2e0(%rsp), %rcx
movq %rax, (%rcx,%r13,8)
incl %r13d
incl %r12d
movq 0x28(%rbx), %rax
movq 0x18(%rax), %rax
movq 0x28(%rax), %rcx
addq $0x20, %rcx
jmp 0x546c
addq $0x2a8, %rsp            # imm = 0x2A8
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
movq 0xd9e9(%rip), %rax      # 0x12ff8
movq (%rax), %rcx
leaq 0x8f5e(%rip), %rdi      # 0xe577
pushq $0x28
popq %rsi
pushq $0x1
popq %rdx
callq 0x1150
pushq $0x1e
jmp 0x5646
movq 0xd9c9(%rip), %rax      # 0x12ff8
movq (%rax), %rcx
leaq 0x8f67(%rip), %rdi      # 0xe5a0
pushq $0x2c
popq %rsi
pushq $0x1
popq %rdx
callq 0x1150
pushq $0x1f
popq %rdi
callq 0x1140
movq 0xd9a5(%rip), %rax      # 0x12ff8
movq (%rax), %rcx
leaq 0x8eee(%rip), %rdi      # 0xe54b
pushq $0x2b
popq %rsi
pushq $0x1
popq %rdx
callq 0x1150
pushq $0x1d
jmp 0x5646