// File: /workspace/github_c_makefile_star2_O2/mishun[P]plantri/fullgen.c
// Function: baue_auf
void baue_auf(PLANMAP map, SEQUENZ sq, int sechsecke)
{

SEQUENZ localseq;
int j, i, laenge;
KANTE *naechste, *nextmark, *run;
int anzahl, naechste_stelle, sql;


if (IPR && (!is_ipr))  return;

sql=sq.laenge;

if (sql >=2)
{
for (i=0; i<sql && ((i==0) || !((sq.k_marks)[i])); i++) 
                                            /* Schleife ueber alle moeglichen Startpunkte */
  {
    laenge=sq.sequenz[i]; 
    if (i==sql-1) naechste_stelle=0; else naechste_stelle=i+1;
    if (laenge==0)
    {
    /* da nie eine 0 am anfang einer kanonischen Sequenz stehen kann, kann die erste einer
       doppel-0 nie am ende stehen, also: */
      if ( (i<sql-1) && (sq.sequenz[i+1]==0) )
	{
	  if (sechsecke >= 1)
	    { 
	      naechste=sq.kanten[i];
	      { add_polygon(6,map,naechste,&naechste); nextmark=naechste; }
	      belege_sequenz(nextmark,&localseq); 
	      if (localseq.k_marks[0])
		{ schreibe_auf(map,localseq,sechsecke-1);
		  baue_auf(map, localseq, sechsecke-1); }
	      /* aufraeumen: */
	      (map[0][0].name) = (map[0][0].name) - 4;
	      run=sq.kanten[i]; run->name=aussen; run->invers=nil; 
	      run=run->next->invers->next; run->name=aussen; run->invers=nil;
	    }   /* ende if ...*/
	  naechste=sq.kanten[i];
	  { add_polygon(5,map,naechste,&naechste); nextmark=naechste; }
	  belege_sequenz(nextmark,&localseq); 
	  if (localseq.k_marks[0])
	    { schreibe_auf(map,localseq,sechsecke);
	      baue_auf(map, localseq, sechsecke); }
	  /* aufraeumen: */
	  is_ipr=1;
	  (map[0][0].name) = (map[0][0].name) - 3;
	  run=sq.kanten[i]; run->name=aussen; run->invers=nil; 
	  run=run->next->invers->next; run->name=aussen; run->invers=nil;

	}

    if (sq.laenge==2) /* nur dann oder im vorigen Fall muss auch an 0er angelegt werden */
    {
    /* In diesem Teil wird die Sequenz nicht a priori berechnet, sondern erst im nachhinein --
       das kostet zwar Zeit, ist aber einfacher und braucht nicht so wahnsinnig viele
       Fallunterscheidungen */

    if (i != 1) { fprintf(stderr,"ERROR: i should be 1 !\n"); exit(26); }
    anzahl= 2 + sq.sequenz[0]; /* Bei laenge 0 muss der naechste mit aufgefuellt werden,
					       um keine Doppel-Innenkanten zu erhalten */

    /* erst nur 6-Ecke */
    if (sechsecke >= anzahl)
      { 
      naechste=sq.kanten[i];
      if (anzahl==1) { add_polygon(6,map,naechste,&naechste); nextmark=naechste; }
        else {
               add_polygon(6,map,naechste,&naechste); nextmark=naechste->prev->invers->prev;
               for (j=1; j<anzahl; j++)  add_polygon(6,map,naechste,&naechste); }
      belege_sequenz(nextmark,&localseq); 
      if (localseq.k_marks[0])
	   { schreibe_auf(map,localseq,sechsecke-anzahl);
	     baue_auf(map, localseq, sechsecke-anzahl); }
      /* aufraeumen: */
      (map[0][0].name) = (map[0][0].name) - 2*anzahl -2;
      run=sq.kanten[i]; run->name=aussen; run->invers=nil; 
      run=run->next->invers->next; run->name=aussen; run->invers=nil;
      for (j=2 ; j<anzahl; j++) { run=run->next->invers->next->invers->next;
	                         run->name=aussen; run->invers=nil; }
      }   /* ende if ...*/



    /* dann ein 5- und 6-Ecke */
    if (sechsecke >= anzahl-1)
      { 
      naechste=sq.kanten[i];
      if (anzahl==1) { add_polygon(5,map,naechste,&naechste); nextmark=naechste; }
        else {
               add_polygon(6,map,naechste,&naechste); nextmark=naechste->prev->invers->prev;
               for (j=1; j<anzahl-1; j++)  add_polygon(6,map,naechste,&naechste);  
               add_polygon(5,map,naechste,&naechste);  }
      belege_sequenz(nextmark,&localseq);
      if (localseq.k_marks[0])
	   { schreibe_auf(map,localseq,sechsecke-anzahl+1);
	     baue_auf(map, localseq, sechsecke-anzahl+1); }
      /* aufraeumen: */
      is_ipr=1;
      (map[0][0].name) = (map[0][0].name) - 2*anzahl-1;
      run=sq.kanten[i]; run->name=aussen; run->invers=nil; 
      run=run->next->invers->next; run->name=aussen; run->invers=nil;
      for (j=2 ; j<anzahl; j++) { run=run->next->invers->next->invers->next;
	                         run->name=aussen; run->invers=nil; }
      }   /* ende if ... */

    /* dann eventuell zwei 5- und der Rest 6-Ecke um es zu 0-Sequenz zu machen */
    if (sechsecke >= anzahl-2)
      {
      naechste=sq.kanten[i];
      add_polygon(5,map,naechste,&naechste); nextmark=naechste->prev->invers->prev;
      for (j=1; j<anzahl-1; j++)  add_polygon(6,map,naechste,&naechste);  
      add_polygon(5,map,naechste,&naechste); 
      belege_sequenz(nextmark,&localseq);
      check_mark_und_schreibe(map,nextmark,localseq.sequenz[0],sechsecke-anzahl+2);

      /* aufraeumen: */
      is_ipr=1;
      (map[0][0].name) = (map[0][0].name) - 2*anzahl;
      run=sq.kanten[i]; run->name=aussen; run->invers=nil; 
      run=run->next->invers->next; run->name=aussen; run->invers=nil;
      for (j=2; j<anzahl; j++) { run=run->next->invers->next->invers->next;
	                         run->name=aussen; run->invers=nil; }

      }   /* ende if */
     } /* ende if sq.laenge==2 */
    } /* ende laenge==0 */


    else /* d.h. laenge !=0 */
    {

    /* ein sonderfall, wenn der naechste ein 0er ist (der erste aber nicht)--
       dann musss da noch ein 6-Eck mehr angefuegt werden: */

      if ((sq.sequenz[naechste_stelle]==0) && (sql>2))
	  { 
	    if (sechsecke >= laenge+1)
	    { 
	      naechste=sq.kanten[i];
              add_polygon(6,map,naechste,&naechste); nextmark=naechste->prev->invers->prev;
	      /* insgesamt laenge+1: */
	      for (j=1; j<=laenge; j++)  add_polygon(6,map,naechste,&naechste);  
	      belege_sequenz(nextmark,&localseq); 
	      if (localseq.k_marks[0])
		{ schreibe_auf(map,localseq,sechsecke-laenge-1);
		  baue_auf(map, localseq, sechsecke-laenge-1); }
              /* aufraeumen: */
	      (map[0][0].name) = (map[0][0].name) - 2*laenge -4;
	      run=sq.kanten[i]; run->name=aussen; run->invers=nil;
	      for (j=0; j<laenge; j++) { run=run->next->invers->next->invers->next;
					 run->name=aussen; run->invers=nil; }
	      run=run->next->invers->next; run->name=aussen; run->invers=nil;

	    }   /* ende if ...*/
	    if (sechsecke >= laenge)
	    { 
	      naechste=sq.kanten[i];
              add_polygon(6,map,naechste,&naechste); nextmark=naechste->prev->invers->prev;
	      /* insgesamt laenge+1: */
	      for (j=1; j<laenge; j++)  add_polygon(6,map,naechste,&naechste);  
	      add_polygon(5,map,naechste,&naechste);  
	      belege_sequenz(nextmark,&localseq); 
	      if (localseq.k_marks[0])
		{ schreibe_auf(map,localseq,sechsecke-laenge);
		  baue_auf(map, localseq, sechsecke-laenge); }
              /* aufraeumen: */
	      is_ipr=1;
	      (map[0][0].name) = (map[0][0].name) - 2*laenge -3;
	      run=sq.kanten[i]; run->name=aussen; run->invers=nil;
	      for (j=0; j<laenge; j++) { run=run->next->invers->next->invers->next;
					 run->name=aussen; run->invers=nil; }
	      run=run->next->invers->next; run->name=aussen; run->invers=nil;

	    }   /* ende if ...*/
	  } /* ende sonderfall naechste_stelle==0-sequenz */



    /* erst nur 6-Ecke */
    if (sechsecke >= laenge)
      { 
      naechste=sq.kanten[i];
      berechne_sequenz(&localseq,sq,i,0);
      if (localseq.k_marks[0])
      {
      if (laenge==1) { add_polygon(6,map,naechste,&naechste); nextmark=naechste;
                       localseq.kanten[0]=nextmark; 
		       localseq.kanten[localseq.laenge-1]=naechste->prev->invers->prev; }
        else {
               add_polygon(6,map,naechste,&naechste); nextmark=naechste->prev->invers->prev;
               for (j=1; j<laenge; j++)  add_polygon(6,map,naechste,&naechste); 
               localseq.kanten[0]=nextmark; localseq.kanten[1]=naechste; }
      if (localseq.k_marks[0])
	   { schreibe_auf(map,localseq,sechsecke-laenge);
	     baue_auf(map, localseq, sechsecke-laenge); }
      /* aufraeumen: */
      (map[0][0].name) = (map[0][0].name) - 2*laenge -1;

      run=sq.kanten[i]; run->name=aussen; run->invers=nil;
      for (j=0; j<laenge; j++) { run=run->next->invers->next->invers->next;
	                         run->name=aussen; run->invers=nil; }
    }/* ende if kanonisch */
      }   /* ende if ...*/



    /* dann ein 5- und 6-Ecke */
    if (sechsecke >= laenge-1)
      { 
      naechste=sq.kanten[i];
      berechne_sequenz(&localseq,sq,i,1); 
      if (localseq.k_marks[0])
      {
      if (laenge==1) { add_polygon(5,map,naechste,&naechste); nextmark=naechste; 
                       localseq.kanten[0]=nextmark; }
        else {
               add_polygon(6,map,naechste,&naechste); nextmark=naechste->prev->invers->prev;
               for (j=1; j<laenge-1; j++)  add_polygon(6,map,naechste,&naechste);  
               add_polygon(5,map,naechste,&naechste);  
               localseq.kanten[0]=nextmark; }
      if (localseq.k_marks[0])
	   { schreibe_auf(map,localseq,sechsecke-laenge+1);
	     baue_auf(map, localseq, sechsecke-laenge+1); }
      /* aufraeumen: */
      is_ipr=1;
      (map[0][0].name) = (map[0][0].name) - 2*laenge;
      run=sq.kanten[i]; run->name=aussen; run->invers=nil;
      for (j=0; j<laenge; j++) { run=run->next->invers->next->invers->next;
	                         run->name=aussen; run->invers=nil; }
    }/* ende if kanonisch */
      }   /* ende if ... */

    /* dann eventuell zwei 5- und der Rest 6-Ecke um es zu 0-Sequenz zu machen */
    if ((laenge>=2) && (sechsecke >= laenge-2) && (sq.laenge==2))
      { 
      naechste=sq.kanten[i];
      berechne_sequenz(&localseq,sq,i,2);
      add_polygon(5,map,naechste,&naechste); nextmark=naechste->prev->invers->prev;
      for (j=1; j<laenge-1; j++)  add_polygon(6,map,naechste,&naechste);  
      add_polygon(5,map,naechste,&naechste); 
      localseq.kanten[0]=nextmark;
      check_mark_und_schreibe(map,nextmark,localseq.sequenz[0],sechsecke-laenge+2);

      /* aufraeumen: */
      is_ipr=1;
      (map[0][0].name) = (map[0][0].name) - 2*laenge + 1;
      run=sq.kanten[i]; run->name=aussen; run->invers=nil;
      for (j=0; j<laenge; j++) { run=run->next->invers->next->invers->next;
	                         run->name=aussen; run->invers=nil; }
      }   /* ende if */
    }/* ende laenge != 0 */
   } /* ende for */

} /* ende if sequenzlaenge >=2 */

else /* d.h. sequenzlaenge==1 */
{
laenge=sq.sequenz[0];

/* erst nur 6-Ecke */
if (laenge && (sechsecke >= (laenge+1)))
 { 
 naechste=sq.kanten[0];
 berechne_sequenz(&localseq,sq,0,0);
 for (j=0; j<=laenge; j++)  add_polygon(6,map,naechste,&naechste);  
 nextmark=naechste;
 localseq.kanten[0]=nextmark;
 schreibe_auf(map,localseq,sechsecke-laenge-1);
 baue_auf(map, localseq, sechsecke-laenge-1); 
 /* aufraeumen: */
 (map[0][0].name) = (map[0][0].name) - 2*laenge -3;

      run=sq.kanten[0]; run->name=aussen; run->invers=nil;
      for (j=0; j<laenge; j++) { run=run->next->invers->next->invers->next;
	                         run->name=aussen; run->invers=nil; }
      }   /* ende if */

/* dann ein 5- und 6-Ecke */
if (laenge && (sechsecke >= laenge))
  {
  naechste=sq.kanten[0];
  berechne_sequenz(&localseq,sq,0,1);
  for (j=0; j<laenge; j++)  add_polygon(6,map,naechste,&naechste);  
  add_polygon(5,map,naechste,&naechste); 
  nextmark=naechste;
  /* das ist zwar zwangslaeufig kanonisch, aber trotzdem: */
  localseq.kanten[0]=nextmark; 
  check_mark_und_schreibe(map,nextmark,localseq.sequenz[0],sechsecke-laenge);
  /* aufraeumen: */
  is_ipr=1;
  (map[0][0].name) = (map[0][0].name) - 2*laenge -2;
  run=sq.kanten[0]; run->name=aussen; run->invers=nil;
  for (j=0; j<laenge; j++) { run=run->next->invers->next->invers->next;
			     run->name=aussen; run->invers=nil; }
      }   /* ende if */


} /* ende else */

}

// Assembly:
pushq %rbp
pushq %r15
pushq %r14
pushq %r13
pushq %r12
pushq %rbx
subq $0x108, %rsp            # imm = 0x108
movl %esi, %r14d
movq %rdi, %rbx
cmpb $0x0, 0xf3e8(%rip)      # 0x13171
je 0x3da6
cmpb $0x0, 0xf3b2(%rip)      # 0x13144
jne 0x3da6
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
leaq 0x140(%rsp), %rsi
movslq (%rsi), %rax
cmpq $0x2, %rax
movq %r14, 0x68(%rsp)
jl 0x4a21
leal -0x1(%rax), %ecx
movq %rcx, 0x98(%rsp)
leal 0x2(%r14), %ecx
movl %ecx, 0x94(%rsp)
leal -0x1(%r14), %ecx
movl %ecx, 0x90(%rsp)
movq %rax, 0x100(%rsp)
movl %eax, 0x78(%rsp)
movq $0x0, 0x80(%rsp)
movq 0x68(%rsp), %rdx
pushq $0xc
popq %rbp
movq 0x80(%rsp), %r12
movq 0x100(%rsp), %r15
cmpq %r15, %r12
je 0x3d94
testq %r12, %r12
je 0x3e2b
cmpb $0x0, 0x58(%rsi,%r12)
jne 0x3d94
movl 0x4(%rsi,%r12,4), %r13d
leaq 0x1(%r12), %rax
testl %r13d, %r13d
movq %r12, 0x70(%rsp)
movq %rax, 0x80(%rsp)
je 0x4465
cmpq 0x98(%rsp), %r12
movl $0x0, %ecx
cmoveq %rcx, %rax
cmpl $0x2, %r15d
je 0x40d7
cmpl $0x0, 0x4(%rsi,%rax,4)
jne 0x40d7
cmpl %r13d, %edx
jle 0x3f98
movq 0x20(%rsi,%r12,8), %r14
movq %r14, 0x60(%rsp)
pushq $0x6
popq %rdi
movq %rbx, %rsi
movq %r14, %rdx
leaq 0x60(%rsp), %rcx
callq 0x2b3c
movq 0x60(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x28(%rax), %rax
movq 0x18(%rax), %r15
testl %r13d, %r13d
movl $0x0, %r12d
cmovgl %r13d, %r12d
movl %r12d, %ebp
subl $0x1, %ebp
jb 0x3ed4
movq 0x60(%rsp), %rdx
pushq $0x6
popq %rdi
movq %rbx, %rsi
leaq 0x60(%rsp), %rcx
callq 0x2b3c
jmp 0x3eb8
movq %r15, %rdi
leaq 0xa0(%rsp), %rbp
movq %rbp, %rsi
callq 0x31b9
cmpb $0x0, 0xf8(%rsp)
movq 0x68(%rsp), %rdx
je 0x3f32
movl %r13d, %r15d
notl %r15d
addl %edx, %r15d
pushq $0xc
popq %rcx
movq %rsp, %rdi
movq %rbp, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
movl %r15d, %esi
callq 0x3ad7
pushq $0xc
popq %rcx
movq %rsp, %rdi
movq %rbp, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
movl %r15d, %esi
callq 0x3d6b
movq 0x68(%rsp), %rdx
movzwl 0x2(%rbx), %eax
leal (,%r13,2), %ecx
negl %ecx
addl %ecx, %eax
addl $-0x4, %eax
movw %ax, 0x2(%rbx)
movw $0x246, 0x2(%r14)       # imm = 0x246
andq $0x0, 0x28(%r14)
leaq 0x140(%rsp), %rsi
pushq $0xc
popq %rbp
movq 0x20(%r14), %rax
movq 0x28(%rax), %rax
movq 0x20(%rax), %rax
subl $0x1, %r12d
jb 0x3f88
movq 0x28(%rax), %rax
movq 0x20(%rax), %r14
movw $0x246, 0x2(%r14)       # imm = 0x246
andq $0x0, 0x28(%r14)
jmp 0x3f60
movw $0x246, 0x2(%rax)       # imm = 0x246
andq $0x0, 0x28(%rax)
movq 0x70(%rsp), %r12
movl %edx, %r15d
subl %r13d, %r15d
jl 0x40d7
movq 0x20(%rsi,%r12,8), %r14
movq %r14, 0x60(%rsp)
pushq $0x6
popq %rdi
movq %rbx, %rsi
movq %r14, %rdx
leaq 0x60(%rsp), %rcx
callq 0x2b3c
movq 0x60(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x28(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, 0x88(%rsp)
pushq $0x1
popq %r12
movq 0x60(%rsp), %rdx
cmpl %r13d, %r12d
jge 0x3ffd
pushq $0x6
popq %rdi
movq %rbx, %rsi
leaq 0x60(%rsp), %rcx
callq 0x2b3c
incl %r12d
jmp 0x3fde
pushq $0x5
popq %rdi
movq %rbx, %rsi
leaq 0x60(%rsp), %rcx
callq 0x2b3c
movq 0x88(%rsp), %rdi
leaq 0xa0(%rsp), %r12
movq %r12, %rsi
callq 0x31b9
cmpb $0x0, 0xf8(%rsp)
je 0x405d
movq %rbp, %rcx
movq %rsp, %rdi
movq %r12, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
movl %r15d, %esi
callq 0x3ad7
movq %rbp, %rcx
movq %rsp, %rdi
movq %r12, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
movl %r15d, %esi
callq 0x3d6b
movb $0x1, 0xf0e0(%rip)      # 0x13144
movzwl 0x2(%rbx), %eax
leal (,%r13,2), %ecx
negl %ecx
addl %ecx, %eax
addl $-0x3, %eax
movw %ax, 0x2(%rbx)
movw $0x246, 0x2(%r14)       # imm = 0x246
andq $0x0, 0x28(%r14)
testl %r13d, %r13d
movl $0x0, %eax
cmovgl %r13d, %eax
leaq 0x140(%rsp), %rsi
movq 0x70(%rsp), %r12
movq 0x68(%rsp), %rdx
movq 0x20(%r14), %rcx
movq 0x28(%rcx), %rcx
movq 0x20(%rcx), %rcx
subl $0x1, %eax
jb 0x40cc
movq 0x28(%rcx), %rcx
movq 0x20(%rcx), %r14
movw $0x246, 0x2(%r14)       # imm = 0x246
andq $0x0, 0x28(%r14)
jmp 0x40a5
movw $0x246, 0x2(%rcx)       # imm = 0x246
andq $0x0, 0x28(%rcx)
movl %edx, %r15d
subl %r13d, %r15d
jl 0x424e
movq 0x20(%rsi,%r12,8), %r14
movq %r14, 0x60(%rsp)
movq %rbp, %rcx
movq %rsp, %rdi
leaq 0x140(%rsp), %rsi
rep  movsq (%rsi), %es:(%rdi)
leaq 0xa0(%rsp), %rdi
movl %r12d, %esi
xorl %edx, %edx
callq 0x2e33
movq 0x68(%rsp), %rdx
leaq 0x140(%rsp), %rsi
cmpb $0x0, 0xf8(%rsp)
je 0x424e
pushq $0x6
popq %rdi
movq %rbx, %rsi
movq %r14, %rdx
leaq 0x60(%rsp), %rcx
callq 0x2b3c
movq 0x60(%rsp), %rax
cmpl $0x1, %r13d
jne 0x4179
movq %rax, 0xc0(%rsp)
movq 0x18(%rax), %rax
movq 0x28(%rax), %rax
movq 0x18(%rax), %rax
movslq 0xa0(%rsp), %rcx
movq %rax, 0xb8(%rsp,%rcx,8)
cmpb $0x0, 0xf8(%rsp)
jne 0x41be
jmp 0x41f4
movq 0x18(%rax), %rax
movq 0x28(%rax), %rax
movq 0x18(%rax), %r12
pushq $0x1
popq %rbp
cmpl %r13d, %ebp
jge 0x41a6
movq 0x60(%rsp), %rdx
pushq $0x6
popq %rdi
movq %rbx, %rsi
leaq 0x60(%rsp), %rcx
callq 0x2b3c
incl %ebp
jmp 0x4188
movq %r12, 0xc0(%rsp)
movq 0x60(%rsp), %rax
movq %rax, 0xc8(%rsp)
pushq $0xc
popq %rbp
movq %rbp, %rcx
movq %rsp, %rdi
leaq 0xa0(%rsp), %r12
movq %r12, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
movl %r15d, %esi
callq 0x3ad7
movq %rbp, %rcx
movq %rsp, %rdi
movq %r12, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
movl %r15d, %esi
callq 0x3d6b
leal (,%r13,2), %eax
notl %eax
addw %ax, 0x2(%rbx)
movw $0x246, 0x2(%r14)       # imm = 0x246
andq $0x0, 0x28(%r14)
testl %r13d, %r13d
movl $0x0, %eax
cmovgl %r13d, %eax
leaq 0x140(%rsp), %rsi
movq 0x68(%rsp), %rdx
subl $0x1, %eax
jb 0x424e
movq 0x20(%r14), %rcx
movq 0x28(%rcx), %rcx
movq 0x20(%rcx), %rcx
movq 0x28(%rcx), %rcx
movq 0x20(%rcx), %r14
movw $0x246, 0x2(%r14)       # imm = 0x246
andq $0x0, 0x28(%r14)
jmp 0x4227
leal -0x1(%r13), %r12d
cmpl %edx, %r12d
jg 0x43d0
movq 0x70(%rsp), %rax
movq 0x20(%rsi,%rax,8), %r14
movq %r14, 0x60(%rsp)
movq %rbp, %rcx
movq %rsp, %rdi
leaq 0x140(%rsp), %rsi
rep  movsq (%rsi), %es:(%rdi)
leaq 0xa0(%rsp), %rdi
movl %eax, %esi
pushq $0x1
popq %rdx
callq 0x2e33
movq 0x68(%rsp), %rdx
leaq 0x140(%rsp), %rsi
cmpb $0x0, 0xf8(%rsp)
je 0x43d0
cmpl $0x1, %r13d
jne 0x42c8
pushq $0x5
popq %rdi
movq %rbx, %rsi
movq %r14, %rdx
leaq 0x60(%rsp), %rcx
callq 0x2b3c
movq 0x60(%rsp), %rax
jmp 0x4330
pushq $0x6
popq %rdi
movq %rbx, %rsi
movq %r14, %rdx
leaq 0x60(%rsp), %rcx
callq 0x2b3c
movq 0x60(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x28(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, 0x88(%rsp)
pushq $0x1
popq %rbp
movq 0x60(%rsp), %rdx
cmpl %r12d, %ebp
jge 0x4315
pushq $0x6
popq %rdi
movq %rbx, %rsi
leaq 0x60(%rsp), %rcx
callq 0x2b3c
incl %ebp
jmp 0x42f7
pushq $0x5
popq %rdi
movq %rbx, %rsi
leaq 0x60(%rsp), %rcx
callq 0x2b3c
pushq $0xc
popq %rbp
movq 0x88(%rsp), %rax
movq %rax, 0xc0(%rsp)
incl %r15d
movq %rbp, %rcx
movq %rsp, %rdi
leaq 0xa0(%rsp), %r12
movq %r12, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
movl %r15d, %esi
callq 0x3ad7
movq %rbp, %rcx
movq %rsp, %rdi
movq %r12, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
movl %r15d, %esi
callq 0x3d6b
movb $0x1, 0xedcc(%rip)      # 0x13144
leal (,%r13,2), %eax
subw %ax, 0x2(%rbx)
movw $0x246, 0x2(%r14)       # imm = 0x246
andq $0x0, 0x28(%r14)
testl %r13d, %r13d
movl $0x0, %eax
cmovgl %r13d, %eax
leaq 0x140(%rsp), %rsi
movq 0x68(%rsp), %rdx
subl $0x1, %eax
jb 0x43d0
movq 0x20(%r14), %rcx
movq 0x28(%rcx), %rcx
movq 0x20(%rcx), %rcx
movq 0x28(%rcx), %rcx
movq 0x20(%rcx), %r14
movw $0x246, 0x2(%r14)       # imm = 0x246
andq $0x0, 0x28(%r14)
jmp 0x43a9
cmpl $0x2, %r13d
jl 0x3e01
cmpl $0x2, 0x78(%rsp)
setne %al
leal -0x2(%r13), %ecx
cmpl %edx, %ecx
setg %cl
orb %al, %cl
jne 0x3e01
movq 0x70(%rsp), %rax
movq 0x20(%rsi,%rax,8), %r14
movq %r14, 0x60(%rsp)
movq %rbp, %rcx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
leaq 0xa0(%rsp), %rdi
movl %eax, %esi
pushq $0x2
popq %rbp
movl %ebp, %edx
callq 0x2e33
pushq $0x5
popq %rdi
movq %rbx, %rsi
movq %r14, %rdx
leaq 0x60(%rsp), %rcx
callq 0x2b3c
movq 0x60(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x28(%rax), %rax
movq 0x18(%rax), %r15
movq 0x60(%rsp), %rdx
cmpl %ebp, %r13d
je 0x4633
pushq $0x6
popq %rdi
movq %rbx, %rsi
leaq 0x60(%rsp), %rcx
callq 0x2b3c
incl %ebp
jmp 0x4443
cmpq 0x98(%rsp), %r12
jae 0x45c4
cmpl $0x0, 0x8(%rsi,%r12,4)
jne 0x45c4
movq 0x20(%rsi,%r12,8), %r14
testl %edx, %edx
leaq 0xa0(%rsp), %r13
jle 0x4526
movq %r14, 0x60(%rsp)
pushq $0x6
popq %rdi
movq %rbx, %rsi
movq %r14, %rdx
leaq 0x60(%rsp), %rcx
callq 0x2b3c
movq 0x60(%rsp), %rdi
movq %r13, %rsi
callq 0x31b9
cmpb $0x0, 0xf8(%rsp)
je 0x44fe
movq %rbp, %rcx
movq %rsp, %rdi
movq %r13, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
movl 0x90(%rsp), %r12d
movl %r12d, %esi
callq 0x3ad7
movq %rbp, %rcx
movq %rsp, %rdi
movq %r13, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
movl %r12d, %esi
movq 0x70(%rsp), %r12
callq 0x3d6b
addw $-0x4, 0x2(%rbx)
movw $0x246, %cx             # imm = 0x246
movw %cx, 0x2(%r14)
andq $0x0, 0x28(%r14)
movq 0x20(%r14), %rax
movq 0x28(%rax), %rax
movq 0x20(%rax), %rax
movw %cx, 0x2(%rax)
andq $0x0, 0x28(%rax)
movq %r14, 0x60(%rsp)
pushq $0x5
popq %rdi
movq %rbx, %rsi
movq %r14, %rdx
leaq 0x60(%rsp), %rcx
callq 0x2b3c
movq 0x60(%rsp), %rdi
movq %r13, %rsi
callq 0x31b9
cmpb $0x0, 0xf8(%rsp)
je 0x458d
movq %rbp, %rcx
movq %rsp, %rdi
movq %r13, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
movq 0x68(%rsp), %r13
movl %r13d, %esi
callq 0x3ad7
movq %rbp, %rcx
movq %rsp, %rdi
leaq 0xa0(%rsp), %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
movl %r13d, %esi
callq 0x3d6b
movb $0x1, 0xebb0(%rip)      # 0x13144
addw $-0x3, 0x2(%rbx)
movw $0x246, %cx             # imm = 0x246
movw %cx, 0x2(%r14)
andq $0x0, 0x28(%r14)
movq 0x20(%r14), %rax
movq 0x28(%rax), %rax
movq 0x20(%rax), %rax
movw %cx, 0x2(%rax)
andq $0x0, 0x28(%rax)
leaq 0x140(%rsp), %rsi
movl %r15d, 0x78(%rsp)
cmpl $0x2, %r15d
jne 0x3df9
cmpq $0x1, %r12
jne 0x4c15
movl 0x4(%rsi), %r15d
leal 0x2(%r15), %r13d
movq 0x68(%rsp), %r12
movl %r12d, %eax
subl %r13d, %eax
movl %eax, 0x70(%rsp)
jge 0x46c4
cmpl %r15d, %r12d
jle 0x490f
movq 0x28(%rsi), %r14
movq %r14, 0x60(%rsp)
cmpl $0x1, %r13d
jne 0x47b5
pushq $0x5
popq %rdi
movq %rbx, %rsi
movq %r14, %rdx
leaq 0x60(%rsp), %rcx
callq 0x2b3c
movq 0x60(%rsp), %rdi
jmp 0x4853
pushq $0x5
popq %rdi
movq %rbx, %rsi
leaq 0x60(%rsp), %rcx
callq 0x2b3c
movq %r15, 0xc0(%rsp)
movl 0xa4(%rsp), %edx
movl 0x94(%rsp), %ecx
subl %r13d, %ecx
movq %rbx, %rdi
movq %r15, %rsi
callq 0x3c28
movb $0x1, 0xead6(%rip)      # 0x13144
movzwl 0x2(%rbx), %eax
leal (,%r13,2), %ecx
negl %ecx
addl %ecx, %eax
incl %eax
movw %ax, 0x2(%rbx)
movw $0x246, 0x2(%r14)       # imm = 0x246
andq $0x0, 0x28(%r14)
leaq 0x140(%rsp), %rsi
subl $0x1, %r13d
jb 0x4a15
movq 0x20(%r14), %rax
movq 0x28(%rax), %rax
movq 0x20(%rax), %rax
movq 0x28(%rax), %rax
movq 0x20(%rax), %r14
movw $0x246, 0x2(%r14)       # imm = 0x246
andq $0x0, 0x28(%r14)
jmp 0x4698
movq 0x28(%rsi), %r14
movq %r14, 0x60(%rsp)
pushq $0x6
popq %rdi
movq %rbx, %rsi
movq %r14, %rdx
leaq 0x60(%rsp), %rcx
callq 0x2b3c
movq 0x60(%rsp), %rbp
cmpl $0x1, %r13d
jne 0x4806
movq %rbp, %rdi
leaq 0xa0(%rsp), %r12
movq %r12, %rsi
callq 0x31b9
cmpb $0x0, 0xf8(%rsp)
pushq $0xc
popq %rbp
je 0x473f
movq %rbp, %rcx
movq %rsp, %rdi
movq %r12, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
movl 0x70(%rsp), %ebp
movl %ebp, %esi
callq 0x3ad7
pushq $0xc
popq %rcx
movq %rsp, %rdi
movq %r12, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
movl %ebp, %esi
callq 0x3d6b
movzwl 0x2(%rbx), %eax
leal (,%r13,2), %ecx
negl %ecx
addl %ecx, %eax
addl $-0x2, %eax
movw %ax, 0x2(%rbx)
movw $0x246, %cx             # imm = 0x246
movw %cx, 0x2(%r14)
andq $0x0, 0x28(%r14)
movq 0x20(%r14), %rax
movq 0x28(%rax), %rax
movq 0x20(%rax), %rax
movw %cx, 0x2(%rax)
andq $0x0, 0x28(%rax)
pushq $0x2
popq %rcx
movq 0x68(%rsp), %r12
leaq 0x140(%rsp), %rsi
cmpl %r13d, %ecx
jge 0x45fa
movq 0x20(%rax), %rax
movq 0x28(%rax), %rax
movq 0x20(%rax), %rax
movq 0x28(%rax), %rax
movq 0x20(%rax), %rax
movw $0x246, 0x2(%rax)       # imm = 0x246
andq $0x0, 0x28(%rax)
incl %ecx
jmp 0x4789
pushq $0x6
popq %rdi
movq %rbx, %rsi
movq %r14, %rdx
leaq 0x60(%rsp), %rcx
callq 0x2b3c
movq 0x60(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x28(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, 0x78(%rsp)
testl %r15d, %r15d
movl $0x0, %ebp
cmovgl %r15d, %ebp
movq 0x60(%rsp), %rdx
subl $0x1, %ebp
jb 0x4839
pushq $0x6
popq %rdi
movq %rbx, %rsi
leaq 0x60(%rsp), %rcx
callq 0x2b3c
jmp 0x47ea
movq 0x18(%rbp), %rax
movq 0x28(%rax), %rax
movq 0x18(%rax), %rbp
pushq $0x1
popq %r12
cmpl %r13d, %r12d
jge 0x46ef
movq 0x60(%rsp), %rdx
pushq $0x6
popq %rdi
movq %rbx, %rsi
leaq 0x60(%rsp), %rcx
callq 0x2b3c
incl %r12d
jmp 0x4816
pushq $0x5
popq %rdi
movq %rbx, %rsi
leaq 0x60(%rsp), %rcx
callq 0x2b3c
movq 0x68(%rsp), %r12
movq 0x78(%rsp), %rdi
leaq 0xa0(%rsp), %rbp
movq %rbp, %rsi
callq 0x31b9
cmpb $0x0, 0xf8(%rsp)
je 0x48a4
movq %rbp, %rsi
movl 0x70(%rsp), %ebp
incl %ebp
pushq $0xc
popq %rcx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
movl %ebp, %esi
callq 0x3ad7
pushq $0xc
popq %rcx
movq %rsp, %rdi
leaq 0xa0(%rsp), %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
movl %ebp, %esi
callq 0x3d6b
movb $0x1, 0xe899(%rip)      # 0x13144
leal (,%r13,2), %eax
notl %eax
addw %ax, 0x2(%rbx)
movw $0x246, %cx             # imm = 0x246
movw %cx, 0x2(%r14)
andq $0x0, 0x28(%r14)
movq 0x20(%r14), %rax
movq 0x28(%rax), %rax
movq 0x20(%rax), %rax
movw %cx, 0x2(%rax)
andq $0x0, 0x28(%rax)
pushq $0x2
popq %rcx
leaq 0x140(%rsp), %rsi
cmpl %r13d, %ecx
jge 0x490f
movq 0x20(%rax), %rax
movq 0x28(%rax), %rax
movq 0x20(%rax), %rax
movq 0x28(%rax), %rax
movq 0x20(%rax), %rax
movw $0x246, 0x2(%rax)       # imm = 0x246
andq $0x0, 0x28(%rax)
incl %ecx
jmp 0x48e7
movl %r12d, %ebp
pushq $0x2
popq %rax
movl %eax, 0x78(%rsp)
subl %r15d, %ebp
jl 0x3df9
movq 0x28(%rsi), %r14
movq %r14, 0x60(%rsp)
pushq $0x5
popq %rdi
movq %rbx, %rsi
movq %r14, %rdx
leaq 0x60(%rsp), %rcx
callq 0x2b3c
movq 0x60(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x28(%rax), %rax
movq 0x18(%rax), %r12
testl %r15d, %r15d
movl $0x0, %eax
cmovlel %eax, %r15d
movq 0x60(%rsp), %rdx
subl $0x1, %r15d
jb 0x4978
pushq $0x6
popq %rdi
movq %rbx, %rsi
leaq 0x60(%rsp), %rcx
callq 0x2b3c
jmp 0x495b
pushq $0x5
popq %rdi
movq %rbx, %rsi
leaq 0x60(%rsp), %rcx
callq 0x2b3c
movq %r12, %rdi
leaq 0xa0(%rsp), %rsi
callq 0x31b9
movl 0xa4(%rsp), %edx
movq %rbx, %rdi
movq %r12, %rsi
movl %ebp, %ecx
callq 0x3c28
movb $0x1, 0xe791(%rip)      # 0x13144
leal (,%r13,2), %eax
subw %ax, 0x2(%rbx)
movw $0x246, %cx             # imm = 0x246
movw %cx, 0x2(%r14)
andq $0x0, 0x28(%r14)
movq 0x20(%r14), %rax
movq 0x28(%rax), %rax
movq 0x20(%rax), %rax
movw %cx, 0x2(%rax)
andq $0x0, 0x28(%rax)
pushq $0x2
popq %rcx
leaq 0x140(%rsp), %rsi
cmpl %r13d, %ecx
jge 0x4a15
movq 0x20(%rax), %rax
movq 0x28(%rax), %rax
movq 0x20(%rax), %rax
movq 0x28(%rax), %rax
movq 0x20(%rax), %rax
movw $0x246, 0x2(%rax)       # imm = 0x246
andq $0x0, 0x28(%rax)
incl %ecx
jmp 0x49ed
pushq $0x2
popq %rax
movl %eax, 0x78(%rsp)
jmp 0x3df9
movl 0x4(%rsi), %r12d
testl %r12d, %r12d
sete %al
cmpl %r12d, %r14d
setle %cl
orb %al, %cl
je 0x4aaa
testl %r12d, %r12d
sete %al
subl %r12d, %r14d
setl %cl
orb %al, %cl
jne 0x3d94
movq %r14, 0x68(%rsp)
movq 0x20(%rsi), %r15
leaq 0x60(%rsp), %r14
movq %r15, (%r14)
pushq $0xc
popq %rcx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
leaq 0xa0(%rsp), %rdi
movq %r12, %r13
xorl %r12d, %r12d
pushq $0x1
popq %rdx
xorl %esi, %esi
callq 0x2e33
testl %r13d, %r13d
movq %r13, 0x80(%rsp)
cmovgl %r13d, %r12d
pushq $0x6
popq %rbp
movl %r12d, %r13d
movq 0x60(%rsp), %rdx
subl $0x1, %r13d
jb 0x4af6
movl %ebp, %edi
movq %rbx, %rsi
movq %r14, %rcx
callq 0x2b3c
jmp 0x4a90
movq 0x20(%rsi), %r13
leaq 0x60(%rsp), %r14
movq %r13, (%r14)
pushq $0xc
popq %rcx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
leaq 0xa0(%rsp), %rdi
xorl %r15d, %r15d
xorl %esi, %esi
xorl %edx, %edx
callq 0x2e33
pushq $0x6
popq %rbp
movq 0x60(%rsp), %rdx
cmpl %r12d, %r15d
jg 0x4b6c
movl %ebp, %edi
movq %rbx, %rsi
movq %r14, %rcx
callq 0x2b3c
incl %r15d
jmp 0x4ad6
pushq $0x5
popq %rdi
leaq 0x60(%rsp), %r14
movq %rbx, %rsi
movq %r14, %rcx
callq 0x2b3c
movq (%r14), %rsi
movl 0xa4(%rsp), %edx
movq %rbx, %rdi
movq 0x68(%rsp), %rcx
callq 0x3c28
movb $0x1, 0xe61d(%rip)      # 0x13144
movzwl 0x2(%rbx), %eax
movq 0x80(%rsp), %rcx
addl %ecx, %ecx
negl %ecx
addl %ecx, %eax
addl $-0x2, %eax
movw %ax, 0x2(%rbx)
movw $0x246, 0x2(%r15)       # imm = 0x246
andq $0x0, 0x28(%r15)
subl $0x1, %r12d
jb 0x3d94
movq 0x20(%r15), %rax
movq 0x28(%rax), %rax
movq 0x20(%rax), %rax
movq 0x28(%rax), %rax
movq 0x20(%rax), %r15
jmp 0x4b40
leaq 0xa0(%rsp), %r14
movq %rdx, 0x20(%r14)
movl %r12d, %ebp
notl %ebp
movq %r12, %r15
movq 0x68(%rsp), %r12
addl %r12d, %ebp
pushq $0xc
popq %rcx
movq %rsp, %rdi
movq %r14, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
movl %ebp, %esi
callq 0x3ad7
pushq $0xc
popq %rcx
movq %rsp, %rdi
movq %r14, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
movl %ebp, %esi
movq %r12, %r14
movq %r15, %r12
callq 0x3d6b
movzwl 0x2(%rbx), %eax
leal (%r15,%r15), %ecx
negl %ecx
addl %ecx, %eax
addl $-0x3, %eax
movw %ax, 0x2(%rbx)
movw $0x246, 0x2(%r13)       # imm = 0x246
andq $0x0, 0x28(%r13)
xorl %eax, %eax
testl %r12d, %r12d
cmovgl %r12d, %eax
leaq 0x140(%rsp), %rsi
subl $0x1, %eax
jb 0x4a35
movq 0x20(%r13), %rcx
movq 0x28(%rcx), %rcx
movq 0x20(%rcx), %rcx
movq 0x28(%rcx), %rcx
movq 0x20(%rcx), %r13
movw $0x246, 0x2(%r13)       # imm = 0x246
andq $0x0, 0x28(%r13)
jmp 0x4bea
movq 0xe3dc(%rip), %rax      # 0x12ff8
movq (%rax), %rcx
leaq 0x990d(%rip), %rdi      # 0xe533
pushq $0x17
popq %rsi
pushq $0x1
popq %rdx
callq 0x1150
pushq $0x1a
popq %rdi
callq 0x1140