// File: /workspace/github_c_makefile_star2_O3/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
movq %rsi, 0x68(%rsp)
movq %rdi, %rbx
cmpb $0x0, 0xf738(%rip)      # 0x15191
je 0x5a68
cmpb $0x0, 0xf702(%rip)      # 0x15164
je 0x6a0b
leaq 0x140(%rsp), %rsi
movslq (%rsi), %r13
cmpq $0x2, %r13
jl 0x67ff
leal -0x1(%r13), %eax
movq %rax, 0xa0(%rsp)
movq 0x68(%rsp), %rax
leal 0x2(%rax), %ecx
movl %ecx, 0x9c(%rsp)
decl %eax
movl %eax, 0x98(%rsp)
leaq 0xa8(%rsp), %rbp
movl %r13d, 0x74(%rsp)
xorl %eax, %eax
movq %r13, 0x90(%rsp)
movq %rax, %r14
testq %rax, %rax
je 0x5acc
cmpb $0x0, 0x58(%rsi,%r14)
jne 0x6a0b
movl 0x4(%rsi,%r14,4), %r12d
leaq 0x1(%r14), %rax
testl %r12d, %r12d
je 0x5c37
cmpq 0xa0(%rsp), %r14
movq %rax, 0x88(%rsp)
movl $0x0, %ecx
cmoveq %rcx, %rax
cmpl $0x2, %r13d
je 0x60ec
cmpl $0x0, 0x4(%rsi,%rax,4)
jne 0x60ec
cmpl %r12d, 0x68(%rsp)
jle 0x5f80
movq %r14, 0x78(%rsp)
movq 0x20(%rsi,%r14,8), %r15
movq %r15, 0x60(%rsp)
movl $0x6, %edi
movq %rbx, %rsi
movq %r15, %rdx
leaq 0x60(%rsp), %r14
movq %r14, %rcx
callq 0x467b
movq 0x60(%rsp), %rax
movq 0x18(%rax), %rax
movq 0x28(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, 0x80(%rsp)
testl %r12d, %r12d
jle 0x5b79
movl %r12d, %r13d
movq 0x60(%rsp), %rdx
movl $0x6, %edi
movq %rbx, %rsi
movq %r14, %rcx
callq 0x467b
decl %r13d
jne 0x5b5f
movq 0x80(%rsp), %rdi
movq %rbp, %rsi
callq 0x4e7d
cmpb $0x0, 0x100(%rsp)
je 0x5bd0
movl %r12d, %r14d
notl %r14d
addl 0x68(%rsp), %r14d
movl $0xc, %ecx
movq %rsp, %rdi
movq %rbp, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
movl %r14d, %esi
callq 0x57b6
movl $0xc, %ecx
movq %rsp, %rdi
movq %rbp, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
movl %r14d, %esi
callq 0x5a39
movzwl 0x2(%rbx), %eax
leal (%r12,%r12), %ecx
negl %ecx
addl %ecx, %eax
addl $-0x4, %eax
movw %ax, 0x2(%rbx)
movw $0x246, 0x2(%r15)       # imm = 0x246
movq $0x0, 0x28(%r15)
testl %r12d, %r12d
jle 0x5f59
movl %r12d, %eax
leaq 0x140(%rsp), %rsi
movq 0x78(%rsp), %r14
movq 0x20(%r15), %rcx
movq 0x28(%rcx), %rcx
movq 0x20(%rcx), %rcx
movq 0x28(%rcx), %rcx
movq 0x20(%rcx), %r15
movw $0x246, 0x2(%r15)       # imm = 0x246
movq $0x0, 0x28(%r15)
decl %eax
jne 0x5c0b
jmp 0x5f66
cmpq 0xa0(%rsp), %r14
jae 0x5dae
cmpl $0x0, 0x4(%rsi,%rax,4)
jne 0x5dae
movq %rax, 0x88(%rsp)
movq 0x20(%rsi,%r14,8), %r15
cmpl $0x0, 0x68(%rsp)
jle 0x5d01
movq %r15, 0x60(%rsp)
movl $0x6, %edi
movq %rbx, %rsi
movq %r15, %rdx
leaq 0x60(%rsp), %rcx
callq 0x467b
movq 0x60(%rsp), %rdi
movq %rbp, %rsi
callq 0x4e7d
cmpb $0x0, 0x100(%rsp)
je 0x5cd9
movl $0xc, %ecx
movq %rsp, %rdi
movq %rbp, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
movq %r14, %r12
movl 0x98(%rsp), %r14d
movl %r14d, %esi
callq 0x57b6
movl $0xc, %ecx
movq %rsp, %rdi
movq %rbp, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
movl %r14d, %esi
movq %r12, %r14
callq 0x5a39
addw $-0x4, 0x2(%rbx)
movw $0x246, %dx             # imm = 0x246
movw %dx, 0x2(%r15)
xorl %ecx, %ecx
movq %rcx, 0x28(%r15)
movq 0x20(%r15), %rax
movq 0x28(%rax), %rax
movq 0x20(%rax), %rax
movw %dx, 0x2(%rax)
movq %rcx, 0x28(%rax)
movq %r15, 0x60(%rsp)
movl $0x5, %edi
movq %rbx, %rsi
movq %r15, %rdx
leaq 0x60(%rsp), %rcx
callq 0x467b
movq 0x60(%rsp), %rdi
movq %rbp, %rsi
callq 0x4e7d
cmpb $0x0, 0x100(%rsp)
je 0x5d6f
movl $0xc, %ecx
movq %rsp, %rdi
movq %rbp, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
movq %r14, %r12
movq 0x68(%rsp), %r14
movl %r14d, %esi
callq 0x57b6
movl $0xc, %ecx
movq %rsp, %rdi
movq %rbp, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
movl %r14d, %esi
movq %r12, %r14
callq 0x5a39
movb $0x1, 0xf3ee(%rip)      # 0x15164
addw $-0x3, 0x2(%rbx)
movw $0x246, %dx             # imm = 0x246
movw %dx, 0x2(%r15)
xorl %ecx, %ecx
movq %rcx, 0x28(%r15)
movq 0x20(%r15), %rax
movq 0x28(%rax), %rax
movq 0x20(%rax), %rax
movw %dx, 0x2(%rax)
movq %rcx, 0x28(%rax)
leaq 0x140(%rsp), %rsi
movq 0x88(%rsp), %rax
movl %r13d, 0x74(%rsp)
cmpl $0x2, %r13d
jne 0x67f1
movq %rax, 0x88(%rsp)
cmpq $0x1, %r14
jne 0x6a1d
movl 0x4(%rsi), %r12d
leal 0x2(%r12), %r14d
movq 0x68(%rsp), %rax
subl %r14d, %eax
movl %eax, 0x74(%rsp)
movq %r14, 0x78(%rsp)
jl 0x5f1c
movq 0x28(%rsi), %r15
movq %r15, 0x60(%rsp)
movl $0x6, %edi
movq %rbx, %rsi
movq %r15, %rdx
leaq 0x60(%rsp), %rcx
callq 0x467b
movq %r14, %rax
movq 0x60(%rsp), %r14
cmpl $0x1, %eax
je 0x5e5f
movq 0x18(%r14), %rax
movq 0x28(%rax), %rax
movq 0x18(%rax), %r14
testl %r12d, %r12d
js 0x5e5f
leal 0x1(%r12), %r13d
leaq 0x60(%rsp), %rbp
movq 0x60(%rsp), %rdx
movl $0x6, %edi
movq %rbx, %rsi
movq %rbp, %rcx
callq 0x467b
decl %r13d
jne 0x5e35
movq 0x90(%rsp), %r13
leaq 0xa8(%rsp), %rbp
movq %r14, %rdi
movq %rbp, %rsi
callq 0x4e7d
cmpb $0x0, 0x100(%rsp)
je 0x5eab
movl $0xc, %ecx
movq %rsp, %rdi
movq %rbp, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
movl 0x74(%rsp), %r14d
movl %r14d, %esi
callq 0x57b6
movl $0xc, %ecx
movq %rsp, %rdi
movq %rbp, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
movl %r14d, %esi
callq 0x5a39
movzwl 0x2(%rbx), %eax
movq 0x78(%rsp), %r14
leal (%r14,%r14), %ecx
negl %ecx
addl %ecx, %eax
addl $-0x2, %eax
movw %ax, 0x2(%rbx)
movw $0x246, %dx             # imm = 0x246
movw %dx, 0x2(%r15)
xorl %ecx, %ecx
movq %rcx, 0x28(%r15)
movq 0x20(%r15), %rax
movq 0x28(%rax), %rax
movq 0x20(%rax), %rax
movw %dx, 0x2(%rax)
movq %rcx, 0x28(%rax)
testl %r12d, %r12d
leaq 0x140(%rsp), %rsi
jle 0x5f1c
movl %r12d, %ecx
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
movq $0x0, 0x28(%rax)
decl %ecx
jne 0x5ef6
cmpl %r12d, 0x68(%rsp)
jle 0x66a3
movq 0x28(%rsi), %r15
movq %r15, 0x60(%rsp)
cmpl $0x1, %r14d
jne 0x6569
movl $0x5, %edi
movq %rbx, %rsi
movq %r15, %rdx
leaq 0x60(%rsp), %rcx
callq 0x467b
movq 0x60(%rsp), %r13
jmp 0x65e2
leaq 0x140(%rsp), %rsi
movq 0x78(%rsp), %r14
movq 0x20(%r15), %rax
movq 0x28(%rax), %rax
movq 0x20(%rax), %rax
movw $0x246, 0x2(%rax)       # imm = 0x246
movq $0x0, 0x28(%rax)
movq 0x68(%rsp), %rax
movl %eax, %r13d
subl %r12d, %r13d
jl 0x60ec
movq 0x20(%rsi,%r14,8), %r15
movq %r15, 0x60(%rsp)
movl $0x6, %edi
movq %rbx, %rsi
movq %r15, %rdx
leaq 0x60(%rsp), %rcx
callq 0x467b
movq 0x60(%rsp), %rdx
movq 0x18(%rdx), %rax
movq 0x28(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, 0x80(%rsp)
cmpl $0x2, %r12d
jl 0x600a
movq %r14, 0x78(%rsp)
leal -0x1(%r12), %r14d
leaq 0x60(%rsp), %rbp
movq 0x60(%rsp), %rdx
movl $0x6, %edi
movq %rbx, %rsi
movq %rbp, %rcx
callq 0x467b
decl %r14d
jne 0x5fde
movq 0x60(%rsp), %rdx
leaq 0xa8(%rsp), %rbp
movq 0x78(%rsp), %r14
movl $0x5, %edi
movq %rbx, %rsi
leaq 0x60(%rsp), %rcx
callq 0x467b
movq 0x80(%rsp), %rdi
movq %rbp, %rsi
callq 0x4e7d
cmpb $0x0, 0x100(%rsp)
je 0x6068
movl $0xc, %ecx
movq %rsp, %rdi
movq %rbp, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
movl %r13d, %esi
callq 0x57b6
movl $0xc, %ecx
movq %rsp, %rdi
movq %rbp, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
movl %r13d, %esi
callq 0x5a39
movb $0x1, 0xf0f5(%rip)      # 0x15164
movzwl 0x2(%rbx), %eax
leal (%r12,%r12), %ecx
negl %ecx
addl %ecx, %eax
addl $-0x3, %eax
movw %ax, 0x2(%rbx)
movw $0x246, 0x2(%r15)       # imm = 0x246
movq $0x0, 0x28(%r15)
testl %r12d, %r12d
jle 0x60ca
movl %r12d, %eax
leaq 0x140(%rsp), %rsi
movq 0x20(%r15), %rcx
movq 0x28(%rcx), %rcx
movq 0x20(%rcx), %rcx
movq 0x28(%rcx), %rcx
movq 0x20(%rcx), %r15
movw $0x246, 0x2(%r15)       # imm = 0x246
movq $0x0, 0x28(%r15)
decl %eax
jne 0x60a1
jmp 0x60d2
leaq 0x140(%rsp), %rsi
movq 0x20(%r15), %rax
movq 0x28(%rax), %rax
movq 0x20(%rax), %rax
movw $0x246, 0x2(%rax)       # imm = 0x246
movq $0x0, 0x28(%rax)
movq 0x68(%rsp), %rax
movl %eax, %r13d
subl %r12d, %r13d
jl 0x627b
movq 0x20(%rsi,%r14,8), %r15
movq %r15, 0x60(%rsp)
movl $0xc, %ecx
movq %rsp, %rdi
leaq 0x140(%rsp), %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbp, %rdi
movl %r14d, %esi
xorl %edx, %edx
callq 0x4988
leaq 0x140(%rsp), %rsi
cmpb $0x0, 0x100(%rsp)
je 0x627b
movl $0x6, %edi
movq %rbx, %rsi
movq %r15, %rdx
leaq 0x60(%rsp), %rcx
callq 0x467b
movq 0x60(%rsp), %rax
cmpl $0x1, %r12d
jne 0x6190
movq %rax, 0xc8(%rsp)
movq 0x18(%rax), %rax
movq 0x28(%rax), %rax
movq 0x18(%rax), %rax
movslq 0xa8(%rsp), %rcx
movq %rax, 0xc0(%rsp,%rcx,8)
cmpb $0x0, 0x100(%rsp)
jne 0x61f9
jmp 0x622b
movq 0x18(%rax), %rcx
movq 0x28(%rcx), %rcx
movq 0x18(%rcx), %rcx
jle 0x61e9
movq %rcx, 0x80(%rsp)
movq %r14, 0x78(%rsp)
leal -0x1(%r12), %r14d
leaq 0x60(%rsp), %rbp
movq 0x60(%rsp), %rdx
movl $0x6, %edi
movq %rbx, %rsi
movq %rbp, %rcx
callq 0x467b
decl %r14d
jne 0x61b5
movq 0x60(%rsp), %rax
leaq 0xa8(%rsp), %rbp
movq 0x78(%rsp), %r14
movq 0x80(%rsp), %rcx
movq %rcx, 0xc8(%rsp)
movq %rax, 0xd0(%rsp)
movl $0xc, %ecx
movq %rsp, %rdi
movq %rbp, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
movl %r13d, %esi
callq 0x57b6
movl $0xc, %ecx
movq %rsp, %rdi
movq %rbp, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
movl %r13d, %esi
callq 0x5a39
leal (%r12,%r12), %eax
notl %eax
addw %ax, 0x2(%rbx)
movw $0x246, 0x2(%r15)       # imm = 0x246
movq $0x0, 0x28(%r15)
testl %r12d, %r12d
leaq 0x140(%rsp), %rsi
jle 0x627b
movl %r12d, %eax
movq 0x20(%r15), %rcx
movq 0x28(%rcx), %rcx
movq 0x20(%rcx), %rcx
movq 0x28(%rcx), %rcx
movq 0x20(%rcx), %r15
movw $0x246, 0x2(%r15)       # imm = 0x246
movq $0x0, 0x28(%r15)
decl %eax
jne 0x6254
leal -0x1(%r12), %eax
cmpl 0x68(%rsp), %eax
jg 0x6411
movq 0x20(%rsi,%r14,8), %r15
movq %r15, 0x60(%rsp)
movl $0xc, %ecx
movq %rsp, %rdi
leaq 0x140(%rsp), %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbp, %rdi
movl %r14d, %esi
movl $0x1, %edx
callq 0x4988
leaq 0x140(%rsp), %rsi
cmpb $0x0, 0x100(%rsp)
je 0x6411
cmpl $0x1, %r12d
jne 0x62f2
movl $0x5, %edi
movq %rbx, %rsi
movq %r15, %rdx
leaq 0x60(%rsp), %rcx
callq 0x467b
movq 0x60(%rsp), %rax
jmp 0x637b
movl $0x6, %edi
movq %rbx, %rsi
movq %r15, %rdx
leaq 0x60(%rsp), %rcx
callq 0x467b
movq 0x60(%rsp), %rdx
movq 0x18(%rdx), %rax
movq 0x28(%rax), %rax
movq 0x18(%rax), %rax
movq %rax, 0x80(%rsp)
cmpl $0x3, %r12d
jl 0x6361
movq %r14, 0x78(%rsp)
leal -0x2(%r12), %r14d
leaq 0x60(%rsp), %rbp
movq 0x60(%rsp), %rdx
movl $0x6, %edi
movq %rbx, %rsi
movq %rbp, %rcx
callq 0x467b
decl %r14d
jne 0x6335
movq 0x60(%rsp), %rdx
leaq 0xa8(%rsp), %rbp
movq 0x78(%rsp), %r14
movl $0x5, %edi
movq %rbx, %rsi
leaq 0x60(%rsp), %rcx
callq 0x467b
movq 0x80(%rsp), %rax
movq %rax, 0xc8(%rsp)
incl %r13d
movl $0xc, %ecx
movq %rsp, %rdi
movq %rbp, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
movl %r13d, %esi
callq 0x57b6
movl $0xc, %ecx
movq %rsp, %rdi
movq %rbp, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
movl %r13d, %esi
callq 0x5a39
movb $0x1, 0xeda5(%rip)      # 0x15164
leal (%r12,%r12), %eax
subw %ax, 0x2(%rbx)
movw $0x246, 0x2(%r15)       # imm = 0x246
movq $0x0, 0x28(%r15)
testl %r12d, %r12d
jle 0x6554
movl %r12d, %eax
leaq 0x140(%rsp), %rsi
movq 0x20(%r15), %rcx
movq 0x28(%rcx), %rcx
movq 0x20(%rcx), %rcx
movq 0x28(%rcx), %rcx
movq 0x20(%rcx), %r15
movw $0x246, 0x2(%r15)       # imm = 0x246
movq $0x0, 0x28(%r15)
decl %eax
jne 0x63ea
cmpl $0x2, %r12d
jl 0x655c
movq %r14, %rdx
leal -0x2(%r12), %r14d
cmpl 0x68(%rsp), %r14d
setle %al
cmpl $0x2, 0x74(%rsp)
sete %cl
andb %al, %cl
cmpb $0x1, %cl
movq 0x90(%rsp), %r13
movq 0x88(%rsp), %rax
jne 0x67f1
movq %rdx, %rax
movq 0x20(%rsi,%rdx,8), %r15
movq %r15, 0x60(%rsp)
movl $0xc, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
movq %rbp, %rdi
movl %eax, %esi
movl $0x2, %edx
callq 0x4988
movl $0x5, %edi
movq %rbx, %rsi
movq %r15, %rdx
leaq 0x60(%rsp), %rbp
movq %rbp, %rcx
callq 0x467b
movq 0x60(%rsp), %rdx
movq 0x18(%rdx), %rax
movq 0x28(%rax), %rax
movq 0x18(%rax), %r13
cmpl $0x2, %r12d
je 0x64c3
movq 0x60(%rsp), %rdx
movl $0x6, %edi
movq %rbx, %rsi
movq %rbp, %rcx
callq 0x467b
decl %r14d
jne 0x64a4
movq 0x60(%rsp), %rdx
movl $0x5, %edi
movq %rbx, %rsi
movq %rbp, %rcx
callq 0x467b
movq %r13, 0xc8(%rsp)
movl 0xac(%rsp), %edx
movl 0x9c(%rsp), %ecx
subl %r12d, %ecx
movq %rbx, %rdi
movq %r13, %rsi
callq 0x591b
movb $0x1, 0xec66(%rip)      # 0x15164
movzwl 0x2(%rbx), %eax
leal (%r12,%r12), %ecx
negl %ecx
addl %ecx, %eax
incl %eax
movw %ax, 0x2(%rbx)
movw $0x246, 0x2(%r15)       # imm = 0x246
movq $0x0, 0x28(%r15)
movq 0x20(%r15), %rax
movq 0x28(%rax), %rax
movq 0x20(%rax), %rax
movq 0x28(%rax), %rax
movq 0x20(%rax), %r15
movw $0x246, 0x2(%r15)       # imm = 0x246
movq $0x0, 0x28(%r15)
decl %r12d
jne 0x651f
movl $0x2, 0x74(%rsp)
jmp 0x67d1
leaq 0x140(%rsp), %rsi
movq 0x90(%rsp), %r13
jmp 0x67e9
movl $0x6, %edi
movq %rbx, %rsi
movq %r15, %rdx
leaq 0x60(%rsp), %rcx
callq 0x467b
movq 0x60(%rsp), %rdx
movq 0x18(%rdx), %rax
movq 0x28(%rax), %rax
movq 0x18(%rax), %r13
testl %r12d, %r12d
jle 0x65d0
movq %r13, 0x80(%rsp)
movl %r12d, %r14d
leaq 0x60(%rsp), %r13
movq 0x60(%rsp), %rdx
movl $0x6, %edi
movq %rbx, %rsi
movq %r13, %rcx
callq 0x467b
decl %r14d
jne 0x65a4
movq 0x60(%rsp), %rdx
movq 0x78(%rsp), %r14
movq 0x80(%rsp), %r13
movl $0x5, %edi
movq %rbx, %rsi
leaq 0x60(%rsp), %rcx
callq 0x467b
movq %r13, %rdi
movq %rbp, %rsi
callq 0x4e7d
cmpb $0x0, 0x100(%rsp)
je 0x6631
movl 0x74(%rsp), %r13d
incl %r13d
movl $0xc, %ecx
movq %rsp, %rdi
movq %rbp, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
movl %r13d, %esi
callq 0x57b6
movl $0xc, %ecx
movq %rsp, %rdi
movq %rbp, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
movl %r13d, %esi
callq 0x5a39
movb $0x1, 0xeb2c(%rip)      # 0x15164
leal (%r14,%r14), %eax
notl %eax
addw %ax, 0x2(%rbx)
movw $0x246, %dx             # imm = 0x246
movw %dx, 0x2(%r15)
xorl %ecx, %ecx
movq %rcx, 0x28(%r15)
movq 0x20(%r15), %rax
movq 0x28(%rax), %rax
movq 0x20(%rax), %rax
movw %dx, 0x2(%rax)
movq %rcx, 0x28(%rax)
testl %r12d, %r12d
leaq 0x140(%rsp), %rsi
movq 0x90(%rsp), %r13
jle 0x66a3
movl %r12d, %ecx
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
movq $0x0, 0x28(%rax)
decl %ecx
jne 0x667d
movl $0x2, 0x74(%rsp)
movq 0x68(%rsp), %rax
movl %eax, %ebp
subl %r12d, %ebp
jl 0x67e1
movq 0x28(%rsi), %r15
movq %r15, 0x60(%rsp)
movl $0x5, %edi
movq %rbx, %rsi
movq %r15, %rdx
leaq 0x60(%rsp), %rcx
callq 0x467b
movq 0x60(%rsp), %rdx
movq 0x18(%rdx), %rax
movq 0x28(%rax), %rax
movq 0x18(%rax), %r13
testl %r12d, %r12d
jle 0x672b
movq %r13, 0x80(%rsp)
movl %r12d, %r14d
leaq 0x60(%rsp), %r13
movq 0x60(%rsp), %rdx
movl $0x6, %edi
movq %rbx, %rsi
movq %r13, %rcx
callq 0x467b
decl %r14d
jne 0x66ff
movq 0x60(%rsp), %rdx
movq 0x78(%rsp), %r14
movq 0x80(%rsp), %r13
movl $0x5, %edi
movq %rbx, %rsi
leaq 0x60(%rsp), %rcx
callq 0x467b
movq %r13, %rdi
leaq 0xa8(%rsp), %rsi
callq 0x4e7d
movl 0xac(%rsp), %edx
movq %rbx, %rdi
movq %r13, %rsi
movl %ebp, %ecx
callq 0x591b
movb $0x1, 0xe9fc(%rip)      # 0x15164
addl %r14d, %r14d
subw %r14w, 0x2(%rbx)
movw $0x246, %dx             # imm = 0x246
movw %dx, 0x2(%r15)
xorl %ecx, %ecx
movq %rcx, 0x28(%r15)
movq 0x20(%r15), %rax
movq 0x28(%rax), %rax
movq 0x20(%rax), %rax
movw %dx, 0x2(%rax)
movq %rcx, 0x28(%rax)
testl %r12d, %r12d
jle 0x67d1
leaq 0x140(%rsp), %rsi
movq 0x90(%rsp), %r13
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
movq $0x0, 0x28(%rax)
decl %r12d
jne 0x67a8
jmp 0x67e1
leaq 0x140(%rsp), %rsi
movq 0x90(%rsp), %r13
leaq 0xa8(%rsp), %rbp
movq 0x88(%rsp), %rax
cmpq %r13, %rax
jne 0x5ab8
jmp 0x6a0b
movl 0x4(%rsi), %r15d
testl %r15d, %r15d
sete %al
cmpl %r15d, 0x68(%rsp)
setle %cl
orb %al, %cl
jne 0x6910
movq 0x20(%rsi), %r12
movq %r12, 0x60(%rsp)
movl $0xc, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
leaq 0xa8(%rsp), %rdi
xorl %esi, %esi
xorl %edx, %edx
callq 0x4988
movq %r12, %rax
testl %r15d, %r15d
js 0x686d
leal 0x1(%r15), %ebp
leaq 0x60(%rsp), %r14
movq 0x60(%rsp), %rdx
movl $0x6, %edi
movq %rbx, %rsi
movq %r14, %rcx
callq 0x467b
decl %ebp
jne 0x684f
movq 0x60(%rsp), %rax
leaq 0xa8(%rsp), %r14
movq %rax, 0x20(%r14)
movl %r15d, %ebp
notl %ebp
addl 0x68(%rsp), %ebp
movl $0xc, %ecx
movq %rsp, %rdi
movq %r14, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
movl %ebp, %esi
callq 0x57b6
movl $0xc, %ecx
movq %rsp, %rdi
movq %r14, %rsi
rep  movsq (%rsi), %es:(%rdi)
movq %rbx, %rdi
movl %ebp, %esi
callq 0x5a39
movzwl 0x2(%rbx), %eax
leal (%r15,%r15), %ecx
negl %ecx
addl %ecx, %eax
addl $-0x3, %eax
movw %ax, 0x2(%rbx)
movw $0x246, 0x2(%r12)       # imm = 0x246
movq $0x0, 0x28(%r12)
testl %r15d, %r15d
leaq 0x140(%rsp), %rsi
jle 0x6910
movl %r15d, %eax
movq 0x20(%r12), %rcx
movq 0x28(%rcx), %rcx
movq 0x20(%rcx), %rcx
movq 0x28(%rcx), %rcx
movq 0x20(%rcx), %r12
movw $0x246, 0x2(%r12)       # imm = 0x246
movq $0x0, 0x28(%r12)
decl %eax
jne 0x68e6
testl %r15d, %r15d
sete %al
movq 0x68(%rsp), %rcx
subl %r15d, %ecx
movq %rcx, 0x68(%rsp)
setl %cl
orb %al, %cl
jne 0x6a0b
movq 0x20(%rsi), %r12
movq %r12, 0x60(%rsp)
movl $0xc, %ecx
movq %rsp, %rdi
rep  movsq (%rsi), %es:(%rdi)
leaq 0xa8(%rsp), %rdi
xorl %esi, %esi
movl $0x1, %edx
callq 0x4988
movq %r12, %rdx
testl %r15d, %r15d
jle 0x6984
leaq 0x60(%rsp), %r14
movl %r15d, %ebp
movq 0x60(%rsp), %rdx
movl $0x6, %edi
movq %rbx, %rsi
movq %r14, %rcx
callq 0x467b
decl %ebp
jne 0x6966
movq 0x60(%rsp), %rdx
leaq 0x60(%rsp), %r14
movl $0x5, %edi
movq %rbx, %rsi
movq %r14, %rcx
callq 0x467b
movq (%r14), %rsi
movl 0xac(%rsp), %edx
movq %rbx, %rdi
movq 0x68(%rsp), %rcx
callq 0x591b
leal (%r15,%r15), %eax
negl %eax
movb $0x1, 0xe7a7(%rip)      # 0x15164
movzwl 0x2(%rbx), %ecx
addl %ecx, %eax
addl $-0x2, %eax
movw %ax, 0x2(%rbx)
movw $0x246, 0x2(%r12)       # imm = 0x246
movq $0x0, 0x28(%r12)
testl %r15d, %r15d
jle 0x6a0b
movq 0x20(%r12), %rax
movq 0x28(%rax), %rax
movq 0x20(%rax), %rax
movq 0x28(%rax), %rax
movq 0x20(%rax), %r12
movw $0x246, 0x2(%r12)       # imm = 0x246
movq $0x0, 0x28(%r12)
decl %r15d
jne 0x69e0
addq $0x108, %rsp            # imm = 0x108
popq %rbx
popq %r12
popq %r13
popq %r14
popq %r15
popq %rbp
retq
callq 0x16e3